def process(entry, result, mode="Num"): Event.process(entry, result) margin = Auction.process(entry, result) Auction_Site.process(entry, result) Auction_BidRequests.process(margin, entry, result, mode) # Response result.append(entry["response"])
def start(self): """ Start the game engine. """ lasttime = time() curtime = 0 frames = 0 # Start the main event loop while 1: # Process the internal event queue Event.handle_events() # Process the SDL event queue for event in SDL.event.get(): if event.type == SDL.QUIT: self.shutdown() elif event.type == SDL.VIDEORESIZE: self.resize(event.w, event.h) elif event.type == SDL.KEYDOWN: StateManager.current.key_pressed(event.key) self.queue_flip() elif event.type == SDL.KEYUP: StateManager.current.key_released(event.key) # Update and draw the current state StateManager.update() self.draw() frames += 1 curtime = time() if curtime - lasttime >= 1: Log.info("FPS: " + str(frames / (curtime - lasttime))) frames = 0 lasttime = curtime
def received_message(self, m): # self.clients is set from within the server # and holds the list of all connected servers # we can dispatch to import json msg = json.loads(str(m)) Event.broadcast(msg['event'], msg['msg']) pass
def createSocket(addr, port): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.bind((addr, port)) rudpSocket = RudpSocket(sock) rudpSocket.addr_src = sock.getsockname() rudpSockets.append(rudpSocket) Event.eventFd(sock.fileno(), handleDataAvailable, rudpSocket, "DataReceived") return rudpSocket
def __handleTimeoutSYN(self, packetSequenceNumber): logger.log(Level.DEBUG, "Handling SYN timeout of:" + str(packetSequenceNumber)) Event.eventTimeoutDelete(self.__handleTimeoutSYN, packetSequenceNumber) if self.__incrementRetries(): packet = self.rudpSocket.generateSynPacket() self.nextAckSeqNumber = packet.seqnum + 1 logger.log(Level.INFO, "Retransmitting SYN") self.rudpSocket.sendPacketControl(self.addr, packet) Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutSYN, packet.seqnum, "SYN timeout")
def __handleTimeoutFIN(self, packetSequenceNumber): logger.log(Level.DEBUG, "Handling FIN timeout of:" + str(packetSequenceNumber)) if self.__incrementRetries(): Event.eventTimeoutDelete(self.__handleTimeoutFIN, packetSequenceNumber) packet = RudpPacket() packet.type = RudpPacket.TYPE_FIN packet.seqnum = packetSequenceNumber self.rudpSocket.sendPacketControl(self.addr, packet) Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutFIN, packet.seqnum, "DATA Timeout")
def __emptyBuffer(self): logger.log(Level.TRACE, "Sending packets, window:" + str(self.window) + " index:" + str(self.nextSendingPacketSeqNumber)) if len(self.dataBuffer) > self.nextSendingPacketSeqNumber: while self.window > 0 and len(self.dataBuffer) > 0 and len(self.dataBuffer) > self.nextSendingPacketSeqNumber: packet = self.dataBuffer[self.nextSendingPacketSeqNumber] self.rudpSocket.sendPacketData(self.addr, packet) self.nextSendingPacketSeqNumber = self.nextSendingPacketSeqNumber + 1 self.window = self.window - 1 Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutData, packet.seqnum, "DATA Timeout")
def fill_insert(classe, i): classe.name = "C"+str(i) classe.planning = Planning() # XXX fill planning with normal events ? #classe.planning.cb_fill(number) # XXX fill planning with course events cursus = db.session.query(Cursus).get(i+1) if cursus: periods = cursus.periods import Event Event.fill_date = cursus.start else: periods = [] for period in periods: for course in period.courses: from Event import Event # XXX move fill event in class event = Event() event.planning = classe.planning event.course = course course.c_elearning_rest = course.c_elearning course.c_classroom_rest = course.c_classroom course.c_practice_rest = course.c_practice course.e_oral_rest = course.e_oral course.e_practice_rest = course.e_practice hours = course.c_elearning hours += course.c_classroom hours += course.c_practice hours += course.e_oral hours += course.e_practice event.cb_fill(hours / 2) if len(period.classes) == 0: for course in period.courses: event = Event() event.planning = period.planning event.course = course event.cb_fill(event.course.e_exam / 2 + 1) import Event Event.fill_date = period.end classe.periods = periods user = User() user.manager_class = [classe] user.cb_fill(randint(1, number), classe.campus.name + '_' + classe.name + '_manager_user' + str(i)) user = User() user.student_class = classe user.cb_fill(randint(10, 30), classe.campus.name+'_'+classe.name+'_student_user'+str(i)) db.session.add(classe)
def __handleTimeoutData(self, rudpSecNum): logger.log(Level.DEBUG, "Handling packet timeout DATA packet seq:" + str(rudpSecNum)) ''' Here we need to remove all other DATA packet timeouts''' for seq in range(rudpSecNum, self.nextSendingPacketSeqNumber): Event.eventTimeoutDelete(self.__handleTimeoutData, seq) if self.__incrementRetries(): ''' Decrease window size, reset packet index to the one we lost''' self.window = 1 if self.window - 1 < 1 else self.window - 1 self.nextSendingPacketSeqNumber = rudpSecNum self.__emptyBuffer() self.retries = self.retries + 1
def createEvents(self): nextDate = next_weekday(datetime.datetime.now().date(),self.day) created = [] skipped = [] while(nextDate < self.endDate): if not Event.getByDate(nextDate): Event.create(self.name,self.place,datetime.datetime.combine(nextDate, self.time),self.key) created.append(nextDate) else: skipped.append(nextDate) nextDate += datetime.timedelta(days=7) return [created,skipped]
def __checkClose(self): ''' Send FIN if all packet have been sent - last packet in a buffer was sent and all have been ACK'ed''' if self.closePending is True: logger.log(Level.DEBUG, str(self.nextBufferPacketSeqNumber) + ">" + str(self.nextSendingPacketSeqNumber) + " >" + str(self.nextAckSeqNumber)) if self.nextBufferPacketSeqNumber == self.nextSendingPacketSeqNumber == (self.nextAckSeqNumber - 1): logger.log(Level.DEBUG, "Closing peer socket:" + str(self)) packet = RudpPacket() packet.type = RudpPacket.TYPE_FIN packet.seqnum = self.dataBuffer[self.nextSendingPacketSeqNumber - 1].seqnum + 1 self.rudpSocket.sendPacketControl(self.addr, packet) Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutFIN, packet.seqnum, "DATA Timeout") self.state = RudpSocket.STATE_CLOSED else: logger.log(Level.DEBUG, "Could not close peer socket yet !!!!")
def old_main(): for line in sys.stdin: event = Event.decode_event(line) # Common handling Global.UpdateThreadState(event) # Event-specific handling event_handler_map[event.event](event)
def main(): print("Handler Chain #1") pipeline = key_handler(mouse_handler(timer_handler())) while True: event = Event.next() if event.kind == Event.TERMINATE: break pipeline.send(event) print("\nHandler Chain #2 (debugging)") pipeline = debug_handler(pipeline) while True: event = Event.next() if event.kind == Event.TERMINATE: break pipeline.send(event)
def process(entry, result, mode="Num"): """ Given a JSON object formatted by Extractor.py, parse each key-value pair in the object. :param entry: the JSON object that represents one impression :param result: the buffer to store the parsed variables :param mode: "Num" or "Bin"; a flag indicating whether to parse bid bloor into binary variables or just keep the numerical value :return: a list containing parsed variables of an impression """ Event.process(entry, result) margin = Auction.process(entry, result) Auction_Site.process(entry, result) Auction_BidRequests.process(margin, entry, result, mode) # Response result.append(entry["response"])
def main(): print("Handler Chain #1") handler1 = TimerHandler(KeyHandler(MouseHandler(NullHandler()))) # Could pass None or nothing instead of the NullHandler while True: event = Event.next() if event.kind == Event.TERMINATE: break handler1.handle(event) print("\nHandler Chain #2 (debugging)") handler2 = DebugHandler(handler1) while True: event = Event.next() if event.kind == Event.TERMINATE: break handler2.handle(event)
def receiveHandler(self, rudpSocket, senderAddress, data): packet = VsPacket().unpack(data) print ">> " + str(packet) ''' Get or create file info object''' fileInfo = None for fInfoTmp in self.files: if fInfoTmp.sender == senderAddress: fileInfo = fInfoTmp if fileInfo is None: fileInfo = FileInfo() fileInfo.sender = senderAddress self.files.append(fileInfo) ''' Handle different VSFTP pacekt types''' if packet.type == VsPacket.TYPE_BEGIN: if fileInfo.filename is not None: print "File already open !!!!" sys.exit(1) filename = packet.data print "GOT PACKET BEGIN, openning fileToWrite for writing:" + filename fileInfo.filename = filename fileInfo.filehandle = open(filename,'w') fileInfo.sendStarted = Event.getCurrentMills() pass elif packet.type == VsPacket.TYPE_DATA: fileInfo.filehandle.write(packet.data) pass elif packet.type == VsPacket.TYPE_END: print "GOT PACKET END, closing file" fileInfo.filehandle.close() self.files.remove(fileInfo) print "Socket closed event received on " + str(rudpSocket) print "Lost Packets:" + str(rudpSocket.packetloss) print "Sent Data packets:" + str(rudpSocket.packetsSentData) print "Sent Control packets:" + str(rudpSocket.packetsSentControl) print "Received packets(total):" + str(rudpSocket.packetsReceived) print "Received data packets:" + str(rudpSocket.packetsReceivedData) print "Received and skipped packets:" + str(rudpSocket.packetsReceivedIgnored) print "Fake loss:" + str(rudpSocket.packetFakeLoss) print "Time taken: " + str((Event.getCurrentMills() - fileInfo.sendStarted)) pass pass
def send(self): self.rudpSocket = Rudp.createSocket(UDP_IP, UDP_PORT) Rudp.registerEventHandler(self.rudpSocket, fileSender.handleEvent) for desination in self.addresses: self.rudpSocket.addPeer(desination) fileToSend = open(self.fileName) Event.eventFd(fileToSend.fileno(), self.handleFileDataAvailable, fileToSend, "FileDataAvailable") print "Openned fileToSend DF:" + str(fileToSend.fileno()) + " name: " + str(self.fileName) ''' Send BEGIN packet''' vsFtpPacket = VsPacket() vsFtpPacket.type = VsPacket.TYPE_BEGIN vsFtpPacket.data = FileSender.processFileName(self.fileName) if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False: print "Transmission error, quiting" sys.exit()
def get_header(): header = [] header.extend(Event.get_header()) header.extend(Auction.get_header()) header.extend(Auction_Site.get_hearder()) header.extend(Auction_BidRequests.get_hearder()) header.append(("response", 1)) return header
def __init__(self, filename): self.filename = filename self.fd = os.open(filename, os.O_RDWR | os.O_NONBLOCK) Controller.__init__(self, LinuxInput.iocGetName(self.fd)) Event.attach(self, "onDisconnect") # Store all the bitfields in a dictionary of lists self.evdevBits = {} for name in LinuxInput.iocGetBitNames(self.fd, None): try: self.evdevBits[name] = LinuxInput.iocGetBitNames(self.fd, name) except KeyError: pass # Store info on each absolute axis self.absAxisInfo = {} for name in self.evdevBits['EV_ABS']: self.absAxisInfo[name] = LinuxInput.iocGetAbs(self.fd, name) # Create actuators for bitName, cls in ( ('EV_ABS', Axis), ('EV_REL', Axis), ('EV_KEY', Button), ): if bitName in self.evdevBits: for itemName in self.evdevBits[bitName]: self.addActuator(cls(itemName)) # Join pairs of axes into joysticks where appropriate for jsName, axisPrefix in ( ('JS_ABS', 'ABS_'), ('JS_ABS_RIGHT', 'ABS_R'), ('JS_ABS_HAT0', 'ABS_HAT0'), ('JS_ABS_HAT1', 'ABS_HAT1'), ('JS_ABS_HAT2', 'ABS_HAT2'), ('JS_ABS_HAT3', 'ABS_HAT3'), ('JS_REL', 'REL_'), ): x, y = axisPrefix + 'X', axisPrefix + 'Y' if x in self.actuators and y in self.actuators: self.addActuator(Joystick(jsName, self.actuators[x], self.actuators[y]))
def handleACK(self, ackPacket): if ackPacket.seqnum != self.nextAckSeqNumber: logger.log(Level.ERROR, "ACK with wrong sequence number, probably arrived too late, ignoring") return if self.state == RudpSocket.STATE_INITING: ''' Must be ACK in response to SYN''' logger.log(Level.DEBUG, "Handling ACK for SYN") self.state = RudpSocket.STATE_ESTABLISHED self.nextAckSeqNumber = 1 Event.eventTimeoutDelete(self.__handleTimeoutSYN, ackPacket.seqnum - 1) self.__emptyBuffer() self.__resetRetries() elif self.state == RudpSocket.STATE_ESTABLISHED: ''' Must be ACK in response to DATA''' logger.log(Level.DEBUG, "Handling ACK for DATA") logger.log(Level.DEBUG, "ACK CORRECT") Event.eventTimeoutDelete(self.__handleTimeoutData, ackPacket.seqnum - 1) self.nextAckSeqNumber = ackPacket.seqnum + 1 self.window = self.window + 1 self.__emptyBuffer() self.__resetRetries() self.__checkClose() elif self.state == RudpSocket.STATE_CLOSED: ''' This must be the final ACK''' logger.log(Level.DEBUG, "Final ACK received:" + str(self.rudpSocket)) Event.eventTimeoutDelete(self.__handleTimeoutFIN, ackPacket.seqnum - 1) self.finished = True self.rudpSocket._peerFinished()
def handleFileDataAvailable(self, fd, fileToSend): data = fileToSend.read(800) if data: vsFtpPacket = VsPacket() vsFtpPacket.type = VsPacket.TYPE_DATA vsFtpPacket.data = data if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False: print "Transmission error, quiting" sys.exit() self.packetcount = self.packetcount + 1 print "### " + str(self.packetcount) #time.sleep(0) else: ''' Send END packet''' vsFtpPacket = VsPacket() vsFtpPacket.type = VsPacket.TYPE_END vsFtpPacket.data = data if self.rudpSocket.sendToAll(vsFtpPacket.pack()) == False: print "Transmission error, quiting" Event.eventFdDelete(self.handleFileDataAvailable, fileToSend) print "File " + self.fileName + " sent" Rudp.closeSocket(self.rudpSocket)
def handleEvent(self, rudpSocket, eventType): if eventType == Event.TYPE_TIMEOUT: sys.exit("TimeOut event received") if eventType == Event.TYPE_CLOSED: print "Socket closed event received on " + str(rudpSocket) print "Lost Packets:" + str(rudpSocket.packetloss) print "Sent Data packets:" + str(rudpSocket.packetsSentData) print "Sent Control packets:" + str(rudpSocket.packetsSentControl) print "Received packets(total):" + str(rudpSocket.packetsReceived) print "Received data packets:" + str(rudpSocket.packetsReceivedData) print "Received and skipped packets:" + str(rudpSocket.packetsReceivedIgnored) print "Fake loss:" + str(rudpSocket.packetFakeLoss) print "Time taken: " + str((Event.getCurrentMills() - self.timeStarted))
def update(self, level): if not self.exploding: return Item.update(self, level) else: size_diff = (self.radius - self.current_size) self.current_size += Interface.tdiff * (size_diff + 0.5) * 2 if self.current_size >= self.radius: if not self.hit_bomb: level.explosion_links[self.explosion_index] = 0 return False for pos in range(len(level.players) - 1, -1, -1): player = level.players[pos] xdiff = player.x - self.x ydiff = player.y - self.y if xdiff * xdiff + ydiff * ydiff <= self.current_size * self.current_size: player.life -= 1 if player.life == 0: Log.info("Killed " + player.name) del level.players[pos] if len(level.players) == 1: Log.info(level.players[0].name + " wins the match!") Event.post(Event.EVENT_MATCH_WON) else: Log.info("Damaged " + player.name) for pos in range(len(level.items) - 1, -1, -1): item = level.items[pos] xdiff = item.x - self.x ydiff = item.y - self.y if xdiff * xdiff + ydiff * ydiff <= self.current_size * self.current_size: if item.type == "Bomb": if item is not self and not item.exploding: self.hit_bomb = True item.timeout(level, self.explosion_index) else: Log.info("Destroyed " + item.type) del level.items[pos] return True
def map(self): import User User.init_db() import Campus Campus.init() import Class Class.init() import ClassRoom ClassRoom.init() import Course Course.init() import Cursus Cursus.init() import Event Event.init() import Period Period.init() import Planning Planning.init() import Settings Settings.init() import University University.init()
def get_header(): """ Get the names of the features in the list returned by process(). Each item is a tuple where the first element is the feature name and the second element is the number of variables that feature contains. :return: a list of tuples containing the feature names and the lengths of the corresponding features """ header = [] header.extend(Event.get_header()) header.extend(Auction.get_header()) header.extend(Auction_Site.get_hearder()) header.extend(Auction_BidRequests.get_hearder()) header.append(("response", 1)) return header
def timeout(self, level, linkindex = -1): self.exploding = True old_time = level.explosion_last level.explosion_last = time() if level.explosion_last - old_time <= .15: level.explosion_counter += 1 else: level.explosion_counter = 1 if level.explosion_counter > 4: Event.post(Event.EVENT_CAMERA_SHAKE) #self.radius *= 2.0 self.explosion_index = linkindex if linkindex == -1: for links in range(len(level.explosion_links)): if level.explosion_links[links] == 0: level.explosion_links[links] = 1 self.explosion_index = links break if self.explosion_index == -1: level.explosion_links.append(1) self.explosion_index = len(level.explosion_links) - 1 else: for pos in range(len(level.items) - 1, -1, -1): item = level.items[pos] xdiff = item.x - self.x ydiff = item.y - self.y if xdiff * xdiff + ydiff * ydiff <= self.radius * self.radius: if item.type == "Bomb": if item is not self and not item.exploding: self.hit_bomb = True level.explosion_links[self.explosion_index] += 1 if level.explosion_links[self.explosion_index] > 4 and not self.hit_bomb: Event.post(Event.EVENT_CAMERA_SHAKE) self.radius *= 1.5 return True
def sendToAll(self, data): if self.state == RudpSocket.STATE_LISTEN: print str(self) + " not ESTABLISHED, sending SYN" packet = self.rudpSocket.generateSynPacket() self.nextAckSeqNumber = packet.seqnum + 1 self.rudpSocket.sendPacketControl(self.addr, packet) self.state = RudpSocket.STATE_INITING Event.eventTimeout(RudpSocket.PARAM_TIMEOUT, self.__handleTimeoutSYN, packet.seqnum, "SYN timeout") elif self.state == RudpSocket.STATE_INITING: logger.log(Level.DEBUG, str(self) + " STATE_INITING, adding data to buffer") elif self.state == RudpSocket.STATE_ESTABLISHED: logger.log(Level.DEBUG, str(self) + " STATE_ESTABLISHED, adding data to buffer") elif self.state == RudpSocket.STATE_CLOSED: logger.log(Level.ERROR, str(self) + " STATE_CLOSED, adding data to buffer") return False # Build packet and add to buffer packet = RudpPacket() packet.type = RudpPacket.TYPE_DATA packet.data = data packet.seqnum = self.nextBufferPacketSeqNumber self.dataBuffer.append(packet) self.nextBufferPacketSeqNumber = self.nextBufferPacketSeqNumber + 1 logger.log(Level.TRACE, "Buffer has packets:" + str(len(self.dataBuffer))) return True
def new_main(): event_list = [] current_time = None for line in sys.stdin: event = Event.decode_event(line) if current_time != event.timestamp: ReorderAndHandleEvents(event_list) del event_list event_list = [] event_list.append(event) current_time = event.timestamp if Global.Graph().number_of_nodes() > 1000000: Global.PrintMemoryUsage() Global.TryCleanupGraph(event.timestamp) Global.PrintMemoryUsage() sys.stderr.flush() sys.stdout.flush() ReorderAndHandleEvents(event_list) del event_list
class InterfaceScaleManager(object): onScaleChanged = Event.Event() def __init__(self, settingsCore): self.proxy = weakref.proxy(settingsCore) self.__index = None self.__scaleValue = None return def init(self): g_guiResetters.add(self.scaleChanged) connectionManager.onConnected += self.scaleChanged connectionManager.onDisconnected += self.scaleChanged self.proxy.onSettingsChanged += self.onSettingsChanged self.scaleChanged() def fini(self): connectionManager.onDisconnected -= self.scaleChanged connectionManager.onConnected -= self.scaleChanged self.proxy.onSettingsChanged -= self.onSettingsChanged g_guiResetters.discard(self.scaleChanged) def get(self): return self.__scaleValue def getIndex(self): return self.__index def onSettingsChanged(self, diff): if settings_constants.GRAPHICS.INTERFACE_SCALE in diff: self.__index = diff[settings_constants.GRAPHICS.INTERFACE_SCALE] self.__scaleValue = self.getScaleByIndex(self.__index) self.onScaleChanged(self.__scaleValue) def scaleChanged(self): self.__index = self.proxy.getSetting( settings_constants.GRAPHICS.INTERFACE_SCALE) self.__scaleValue = self.getScaleByIndex(self.__index) self.onScaleChanged(self.__scaleValue) def getScaleOptions(self): options = self._getOptions() currMonitor = g_monitorSettings.activeMonitor if self.proxy.getSetting(settings_constants.GRAPHICS.FULLSCREEN): resolutionInd = self.proxy.getSetting( settings_constants.GRAPHICS.RESOLUTION) return options[1][currMonitor][resolutionInd] else: return options[0][currMonitor][self.proxy.getSetting( settings_constants.GRAPHICS.WINDOW_SIZE)] def getScaleByIndex(self, ind, powerOfTwo=True): scaleLength = len(self.getScaleOptions()) if powerOfTwo: if ind == 0: return 2.0**(scaleLength - 2) else: return 2.0**(ind - 1) else: if ind == 0: return scaleLength - 1 return ind def _getOptions(self): return [ self.__getScales(graphics.getSuitableWindowSizes(), BigWorld.wg_getCurrentResolution(True)), self.__getScales(graphics.getSuitableVideoModes()) ] def __getScales(self, modesVariety, additionalSize=None): result = [] for i in xrange(len(modesVariety)): modes = sorted( set([(mode.width, mode.height) for mode in modesVariety[i]])) if additionalSize is not None: modes.append(additionalSize[0:2]) result.append(map(graphics.getInterfaceScalesList, modes)) return result
def make_gold_set(): ''' handcrafted set of events from testing data empty if n.A. (better for comaprison with results) :return: list of gold-standard Event objects ''' gold_standard = [] p3s11 = Event.Event( component1="Bartonella tribocorum", component2=["the blood of wild rats", "fleas obtained from wild rats"]) p3s12 = Event.Event(component1="Bartonella elizabethae", component2="a case of endocarditis in a human") p3s14 = Event.Event(component1="This organism", component2="the blood of wild rats") p6s4 = Event.Event(component1="This species", component2="the feces of a breast-fed infant") p7s5 = Event.Event( component1="Most of the ~30 known species of bifidobacteria", component2=["the mammalian GIT", "the vaginal and oral cavity"]) p8s6 = Event.Event( component1="Most of the ~30 known species of bifidobacteria", component2=["the mammalian GIT", "the vaginal and oral cavity"]) p8s13 = Event.Event(component1="This strain", component2="human infant feces") p11s3 = Event.Event(component1=" ", component2=" ") p11s4 = Event.Event( component1="Burkholderia ambifaria AMMD", component2= "the rhizosphere of pea -LRB- Pisum sativum L. -RRB- near Arlington, Wisconsin, USA" ) p12s3 = Event.Event( component1="the reference strain, CH34", component2= "the sludge of a zinc decantation tank in Belgium that was polluted with high concentrations of several heavy metals" ) p13s12 = Event.Event( component1="Dehalococcoides sp. strain BAV1", component2= "PCE-to-ethene-dechlorinating microcosms established with aquifer material collected at the contaminated Bachman Road site in Oscoda, Michigan -LRB- 6-8, 13 -RRB-" ) p14s1 = Event.Event( component1="Desulfococcus oleovorans Hxd3", component2= "the saline water phase of an oil-water separator from a northern German oil field -LRB- 1,2 -RRB-" ) p16s8 = Event.Event(component1="D. deserti", component2="the Sahara desert") p17s3 = Event.Event(component1="the first strain of Tropheryma whipplei", component2=" ") p18s14 = Event.Event(component1="the genes", component2="in eukaryotes") p19s1 = Event.Event( component1="Thermoanaerobacter tengcongensis", component2="a freshwater hot spring in Tengchong, China") p21s3 = Event.Event(component1="The sequenced strain", component2="Beppu hot spring in Japan") p22s1 = Event.Event( component1="Thermotoga maritima", component2="geothermal heated marine sediment at Vulcano, Italy") p23s2 = Event.Event(component1="The organism, strain HB27", component2="a natural thermal environment in Japan") p25s3 = Event.Event(component1="D. aromatica strain RCB", component2="Potomic River sediment, Maryland, USA") p25s31 = Event.Event(component1="Dechloromonas aromatica", component2=" ") p25s32 = Event.Event(component1="two unrelated strains, RCB and JJ,", component2="two very diverse environments") p26s2 = Event.Event( component1="It", component2="soil contaminated with chlorinated industrial products") p26s5 = Event.Event( component1="D. restrictus", component2= "a laboratory system that was being fed with tetrachloroethene") p27s11 = Event.Event( component1="The S. meliloti genome", component2= "nodules and soil primarily from host plants such as the Medicago -LRB- alfalfa and perennial and annual medics -RRB-, Melilotus -LRB- sweet clover -RRB-, and Trigonella -LRB- fenugreek -RRB- species -LRB- 11 -RRB-" ) p27s62 = Event.Event(component1=" ", component2=" ") gold_standard.append(p3s11) gold_standard.append(p3s12) gold_standard.append(p3s14) gold_standard.append(p6s4) gold_standard.append(p7s5) gold_standard.append(p8s6) gold_standard.append(p8s13) gold_standard.append(p11s3) gold_standard.append(p11s4) gold_standard.append(p12s3) gold_standard.append(p13s12) gold_standard.append(p14s1) gold_standard.append(p16s8) gold_standard.append(p17s3) gold_standard.append(p18s14) gold_standard.append(p19s1) gold_standard.append(p21s3) gold_standard.append(p22s1) gold_standard.append(p23s2) gold_standard.append(p25s3) gold_standard.append(p25s31) gold_standard.append(p25s32) gold_standard.append(p26s2) gold_standard.append(p26s5) gold_standard.append(p27s11) gold_standard.append(p27s62) return gold_standard
def __init__(self): super(AvatarStatsController, self).__init__() self.__stats = {} self.__eManager = Event.EventManager() self.onUpdated = Event.Event(self.__eManager)
def __init__(self): self.onUpdated = Event.Event() self.__newOffers = set()
def proceed(self): # 결과를 제출할 이벤트 인스턴스 생성 myEvent = Event() myEvent.setStartTime(self.startTime.text()) myEvent.setEndTime(self.endTime.text()) # 상품을 사전에 등록 dic = {} selectedNum = int(self.prizeComboBox.currentText()) for i in range(0, selectedNum): dic[self.prizeEdit[i].text()] = self.prizeSpinBox[i].value() myEvent.setPrize(dic) print("당첨자 엑셀을 생성합니다") # 체리피커 필터링 if (self.checkBox_Cherry.isChecked() is True): myEvent.setOpt_Cherry(["초대", "함께해", "함께해요"]) print("체리피커 필터링이 활성화 되었습니다") # URL 체크 if (self.checkBox_URL.isChecked() is True): myEvent.setOpt_URL(["www", "facebook"]) print("URL 체크가 활성화 되었습니다") # 이벤트 키워드 체크 if (self.checkBox_Keyword.isChecked() is True): if not (self.keywordEdit1.text() is None): myEvent.setOpt_Keywords([self.keywordEdit1.text()]) if not (self.keywordEdit2.text() is None): myEvent.setOpt_Keywords([self.keywordEdit2.text()]) if not (self.keywordEdit3.text() is None): myEvent.setOpt_Keywords([self.keywordEdit3.text()]) if not (self.keywordEdit4.text() is None): myEvent.setOpt_Keywords([self.keywordEdit4.text()]) print("키워드 체크가 활성화 되었습니다") print("체리필터 키워드 : " + str(myEvent.getOpt_Cherry())) print("URL 체크 키워드 : " + str(myEvent.getOpt_URL())) print("이벤트 당첨 키워드 : " + str(myEvent.getOpt_Keywords())) generateExcel(myEvent) self.progressBar.setValue(self.progressBar.maximum()) popup = QtWidgets.QMessageBox(self) popup.setGeometry(100, 200, 100, 100) popup.information(self, "Complete", "당첨자 엑셀이 생성되었습니다.", QtWidgets.QMessageBox.Yes)
def notify(self, message): self.emit(Event.Event(details={'notification': message}))
def __init__(self): super(RentalsController, self).__init__() self.onRentChangeNotify = Event.Event() self.__rentNotifyTimeCallback = None self.__vehiclesForUpdate = [] return
#!/usr/bin/python # -*- encoding: utf-8 -*- import matplotlib.pyplot as plt import Event import MyConf import numpy as np event = Event.Event() attackFile = "./ex_attack.txt" noiseFile = "./ex_noise.txt" event.loadAttack(attackFile) event.loadNoiseWithLearning(noiseFile, 600) event.calcTotal() event.calcTotalScore(useLearningData = True) total = event.total score = event.totalScore fig = plt.figure(figsize=(16,9)) # aspect ratio plt.rcParams['font.size'] = 30 # default font size plt.rcParams['font.family'] = 'serif' # default font family plt.rcParams['legend.fontsize'] = 30 # default font size of legend plt.tick_params(pad=15) # pad: Distance in points between tick and label. ax = fig.add_subplot(1, 1, 1) # 1 * 1 grid, and 1st subplot ax2 = ax.twinx() ax.set_xlabel('$t$') # X tick label ax.set_ylabel('Number of traceroute packets $x_t$') # Y tick label ax2.set_ylabel('Abnormality $a_i$') ax2.yaxis.set_label_coords(1.08, 0.5)
import string import Interface import Event import App from chat import * #Chat manager from Interface import * from Event import * from App import * import feedparser ########################################################### ######Global variables I = Interface.get() #Interface manager A = App.get() #Application E = Event.get() #Event manager ########################################################## #####Counter, returns new value every time def counter(): static_counter = 0 while True: static_counter += 1 yield static_counter count = counter().next ######################################################################### #####Function creates simple message box with specified title and name #####Message box has one button - ok and is destroyed by interface manager #####after pressing this button. #####Every new popup window has unique id. def createPopupWindow(title,text): name = 'PopupWindow' + str(count())
def fill_insert(classe, i): classe.name = "C" + str(i) classe.planning = Planning() # XXX fill planning with normal events ? #classe.planning.cb_fill(number) # XXX fill planning with course events cursus = db.session.query(Cursus).get(i + 1) if cursus: periods = cursus.periods import Event Event.fill_date = cursus.start else: periods = [] for period in periods: for course in period.courses: from Event import Event # XXX move fill event in class event = Event() event.planning = classe.planning event.course = course course.c_elearning_rest = course.c_elearning course.c_classroom_rest = course.c_classroom course.c_practice_rest = course.c_practice course.e_oral_rest = course.e_oral course.e_practice_rest = course.e_practice hours = course.c_elearning hours += course.c_classroom hours += course.c_practice hours += course.e_oral hours += course.e_practice event.cb_fill(hours / 2) if len(period.classes) == 0: for course in period.courses: event = Event() event.planning = period.planning event.course = course event.cb_fill(event.course.e_exam / 2 + 1) import Event Event.fill_date = period.end classe.periods = periods user = User() user.manager_class = [classe] user.cb_fill( randint(1, number), classe.campus.name + '_' + classe.name + '_manager_user' + str(i)) user = User() user.student_class = classe user.cb_fill( randint(10, 30), classe.campus.name + '_' + classe.name + '_student_user' + str(i)) db.session.add(classe)
def __init__(self, cppObject=None): super(WindowsManager, self).__init__(cppObject) self.__eManager = Event.EventManager() self.onWindowStatusChanged = Event.Event(self.__eManager) self.onViewStatusChanged = Event.Event(self.__eManager)
class _SettingsCore(object): onSettingsChanged = Event.Event() def init(self): from account_helpers.settings_core import options, settings_storages, settings_constants from gui.shared.utils import graphics GAME = settings_constants.GAME TUTORIAL = settings_constants.TUTORIAL GRAPHICS = settings_constants.GRAPHICS SOUND = settings_constants.SOUND CONTROLS = settings_constants.CONTROLS AIM = settings_constants.AIM MARKERS = settings_constants.MARKERS OTHER = settings_constants.OTHER self.__serverSettings = ServerSettingsManager(self) self.interfaceScale = InterfaceScaleManager(self) VIDEO_SETTINGS_STORAGE = settings_storages.VideoSettingsStorage(self.serverSettings, self) GAME_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAME) EXTENDED_GAME_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAME_EXTENDED) TUTORIAL_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.TUTORIAL) GAMEPLAY_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GAMEPLAY) GRAPHICS_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.GRAPHICS) SOUND_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.SOUND) KEYBOARD_SETTINGS_STORAGE = settings_storages.KeyboardSettingsStorage(self.serverSettings, self) CONTROLS_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.CONTROLS) AIM_SETTINGS_STORAGE = settings_storages.AimSettingsStorage(self.serverSettings, self) MARKERS_SETTINGS_STORAGE = settings_storages.MarkersSettingsStorage(self.serverSettings, self) MARK_ON_GUN_SETTINGS_STORAGE = settings_storages.ServerSettingsStorage(self.serverSettings, self, SETTINGS_SECTIONS.MARKS_ON_GUN) FOV_SETTINGS_STORAGE = settings_storages.FOVSettingsStorage(self.serverSettings, self) MESSENGER_SETTINGS_STORAGE = settings_storages.MessengerSettingsStorage(GAME_SETTINGS_STORAGE) EXTENDED_MESSENGER_SETTINGS_STORAGE = settings_storages.MessengerSettingsStorage(EXTENDED_GAME_SETTINGS_STORAGE) self.__storages = {'game': GAME_SETTINGS_STORAGE, 'extendedGame': EXTENDED_GAME_SETTINGS_STORAGE, 'gameplay': GAMEPLAY_SETTINGS_STORAGE, 'sound': SOUND_SETTINGS_STORAGE, 'keyboard': KEYBOARD_SETTINGS_STORAGE, 'controls': CONTROLS_SETTINGS_STORAGE, 'aim': AIM_SETTINGS_STORAGE, 'markers': MARKERS_SETTINGS_STORAGE, 'graphics': GRAPHICS_SETTINGS_STORAGE, 'video': VIDEO_SETTINGS_STORAGE, 'messenger': MESSENGER_SETTINGS_STORAGE, 'extendedMessenger': EXTENDED_MESSENGER_SETTINGS_STORAGE, 'marksOnGun': MARK_ON_GUN_SETTINGS_STORAGE, 'FOV': FOV_SETTINGS_STORAGE, 'tutorial': TUTORIAL_SETTINGS_STORAGE} self.isDeviseRecreated = False self.isChangesConfirmed = True self.__options = options.SettingsContainer(((GAME.REPLAY_ENABLED, options.ReplaySetting(GAME.REPLAY_ENABLED, storage=GAME_SETTINGS_STORAGE)), (GAME.ENABLE_SERVER_AIM, options.StorageAccountSetting(GAME.ENABLE_SERVER_AIM, storage=GAME_SETTINGS_STORAGE)), (GAME.MINIMAP_ALPHA, options.StorageAccountSetting(GAME.MINIMAP_ALPHA, storage=GAME_SETTINGS_STORAGE)), (GAME.ENABLE_POSTMORTEM, options.PostProcessingSetting(GAME.ENABLE_POSTMORTEM, 'mortem_post_effect', storage=GAME_SETTINGS_STORAGE)), (GAME.ENABLE_POSTMORTEM_DELAY, options.PostMortemDelaySetting(GAME.ENABLE_POSTMORTEM_DELAY, storage=GAME_SETTINGS_STORAGE)), (GAME.SHOW_VEHICLES_COUNTER, options.StorageAccountSetting(GAME.SHOW_VEHICLES_COUNTER, storage=GAME_SETTINGS_STORAGE)), (GAME.SHOW_BATTLE_EFFICIENCY_RIBBONS, options.ExcludeInReplayAccountSetting(GAME.SHOW_BATTLE_EFFICIENCY_RIBBONS, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.BATTLE_LOADING_INFO, options.BattleLoadingTipSetting(GAME.BATTLE_LOADING_INFO, GAME.BATTLE_LOADING_INFO)), (GAME.SIMPLIFIED_TTC, options.StorageAccountSetting(GAME.SIMPLIFIED_TTC, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.SHOW_MARKS_ON_GUN, options.ShowMarksOnGunSetting(GAME.SHOW_MARKS_ON_GUN, storage=MARK_ON_GUN_SETTINGS_STORAGE)), (GAME.DYNAMIC_CAMERA, options.DynamicCamera(GAME.DYNAMIC_CAMERA, storage=GAME_SETTINGS_STORAGE)), (GAME.INCREASED_ZOOM, options.IncreasedZoomSetting(GAME.INCREASED_ZOOM, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.SNIPER_MODE_BY_SHIFT, options.SnipereModeByShiftSetting(GAME.SNIPER_MODE_BY_SHIFT, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.SNIPER_MODE_STABILIZATION, options.SniperModeStabilization(GAME.SNIPER_MODE_STABILIZATION, storage=GAME_SETTINGS_STORAGE)), (GAME.ENABLE_OL_FILTER, options.MessengerSetting(GAME.ENABLE_OL_FILTER, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.ENABLE_SPAM_FILTER, options.MessengerSetting(GAME.ENABLE_SPAM_FILTER, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.SHOW_DATE_MESSAGE, options.MessengerDateTimeSetting(1, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.SHOW_TIME_MESSAGE, options.MessengerDateTimeSetting(2, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.INVITES_FROM_FRIENDS, options.MessengerSetting(GAME.INVITES_FROM_FRIENDS, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.RECEIVE_CLAN_INVITES_NOTIFICATIONS, options.ClansSetting(GAME.RECEIVE_CLAN_INVITES_NOTIFICATIONS, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.RECEIVE_FRIENDSHIP_REQUEST, options.MessengerSetting(GAME.RECEIVE_FRIENDSHIP_REQUEST, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.RECEIVE_INVITES_IN_BATTLE, options.MessengerSetting(GAME.RECEIVE_INVITES_IN_BATTLE, storage=EXTENDED_MESSENGER_SETTINGS_STORAGE)), (GAME.DISABLE_BATTLE_CHAT, options.MessengerSetting(GAME.DISABLE_BATTLE_CHAT, storage=MESSENGER_SETTINGS_STORAGE)), (GAME.CHAT_CONTACTS_LIST_ONLY, options.MessengerSetting(GAME.CHAT_CONTACTS_LIST_ONLY, storage=EXTENDED_MESSENGER_SETTINGS_STORAGE)), (GAME.PLAYERS_PANELS_SHOW_LEVELS, options.PlayersPanelSetting(GAME.PLAYERS_PANELS_SHOW_LEVELS, 'players_panel', 'showLevels', storage=GAME_SETTINGS_STORAGE)), (GAME.PLAYERS_PANELS_SHOW_TYPES, options.AccountDumpSetting(GAME.PLAYERS_PANELS_SHOW_TYPES, 'players_panel', 'showTypes')), (GAME.PLAYERS_PANELS_STATE, options.AccountDumpSetting(GAME.PLAYERS_PANELS_STATE, 'players_panel', 'state')), (GAME.SNIPER_MODE_SWINGING_ENABLED, options.SniperModeSwingingSetting()), (GAME.GAMEPLAY_CTF, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'ctf', storage=GAMEPLAY_SETTINGS_STORAGE)), (GAME.GAMEPLAY_DOMINATION, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'domination', storage=GAMEPLAY_SETTINGS_STORAGE)), (GAME.GAMEPLAY_ASSAULT, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'assault', storage=GAMEPLAY_SETTINGS_STORAGE)), (GAME.GAMEPLAY_NATIONS, options.GameplaySetting(GAME.GAMEPLAY_MASK, 'nations', storage=GAMEPLAY_SETTINGS_STORAGE)), (GAME.LENS_EFFECT, options.LensEffectSetting(GAME.LENS_EFFECT, storage=GRAPHICS_SETTINGS_STORAGE)), (GAME.SHOW_VECTOR_ON_MAP, options.MinimapSetting(GAME.SHOW_VECTOR_ON_MAP, storage=GAME_SETTINGS_STORAGE)), (GAME.SHOW_SECTOR_ON_MAP, options.MinimapSetting(GAME.SHOW_SECTOR_ON_MAP, storage=GAME_SETTINGS_STORAGE)), (GAME.SHOW_VEH_MODELS_ON_MAP, options.MinimapVehModelsSetting(GAME.SHOW_VEH_MODELS_ON_MAP, storage=GAME_SETTINGS_STORAGE)), (GAME.MINIMAP_VIEW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_VIEW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.MINIMAP_MAX_VIEW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_MAX_VIEW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GAME.MINIMAP_DRAW_RANGE, options.StorageAccountSetting(GAME.MINIMAP_DRAW_RANGE, storage=EXTENDED_GAME_SETTINGS_STORAGE)), (GRAPHICS.MONITOR, options.MonitorSetting(storage=VIDEO_SETTINGS_STORAGE)), (GRAPHICS.WINDOW_SIZE, options.WindowSizeSetting(storage=VIDEO_SETTINGS_STORAGE)), (GRAPHICS.RESOLUTION, options.ResolutionSetting(storage=VIDEO_SETTINGS_STORAGE)), (GRAPHICS.REFRESH_RATE, options.RefreshRateSetting(storage=VIDEO_SETTINGS_STORAGE)), (GRAPHICS.FULLSCREEN, options.FullscreenSetting(storage=VIDEO_SETTINGS_STORAGE)), (GRAPHICS.COLOR_BLIND, options.AccountDumpSetting(GRAPHICS.COLOR_BLIND, GRAPHICS.COLOR_BLIND)), (GRAPHICS.GRAPHICS_QUALITY_HD_SD, options.GraphicsQualityNote()), (GRAPHICS.GAMMA, options.GammaSetting()), (GRAPHICS.TRIPLE_BUFFERED, options.TripleBufferedSetting()), (GRAPHICS.VERTICAL_SYNC, options.VerticalSyncSetting()), (GRAPHICS.MULTISAMPLING, options.MultisamplingSetting()), (GRAPHICS.CUSTOM_AA, options.CustomAASetting()), (GRAPHICS.ASPECT_RATIO, options.AspectRatioSetting()), (GRAPHICS.FPS_PERFOMANCER, options.FPSPerfomancerSetting(GRAPHICS.FPS_PERFOMANCER, storage=GRAPHICS_SETTINGS_STORAGE)), (GRAPHICS.DRR_AUTOSCALER_ENABLED, options.GraphicSetting(GRAPHICS.DRR_AUTOSCALER_ENABLED)), (GRAPHICS.DYNAMIC_RENDERER, options.DynamicRendererSetting()), (GRAPHICS.COLOR_FILTER_INTENSITY, options.ColorFilterIntensitySetting()), (GRAPHICS.COLOR_FILTER_IMAGES, options.ReadOnlySetting(lambda : graphics.getGraphicSettingImages(GRAPHICS.COLOR_GRADING_TECHNIQUE))), (GRAPHICS.FOV, options.FOVSetting(GRAPHICS.FOV, storage=FOV_SETTINGS_STORAGE)), (GRAPHICS.DYNAMIC_FOV_ENABLED, options.DynamicFOVEnabledSetting(storage=FOV_SETTINGS_STORAGE)), (GRAPHICS.PRESETS, options.GraphicsPresetSetting()), (GRAPHICS.RENDER_PIPELINE, options.GraphicSetting(GRAPHICS.RENDER_PIPELINE)), (GRAPHICS.TEXTURE_QUALITY, options.TextureQualitySetting()), (GRAPHICS.DECALS_QUALITY, options.GraphicSetting(GRAPHICS.DECALS_QUALITY)), (GRAPHICS.OBJECT_LOD, options.GraphicSetting(GRAPHICS.OBJECT_LOD)), (GRAPHICS.FAR_PLANE, options.GraphicSetting(GRAPHICS.FAR_PLANE)), (GRAPHICS.TERRAIN_QUALITY, options.TerrainQualitySetting()), (GRAPHICS.SHADOWS_QUALITY, options.GraphicSetting(GRAPHICS.SHADOWS_QUALITY)), (GRAPHICS.LIGHTING_QUALITY, options.GraphicSetting(GRAPHICS.LIGHTING_QUALITY)), (GRAPHICS.SPEEDTREE_QUALITY, options.GraphicSetting(GRAPHICS.SPEEDTREE_QUALITY)), (GRAPHICS.FLORA_QUALITY, options.FloraQualitySetting()), (GRAPHICS.WATER_QUALITY, options.GraphicSetting(GRAPHICS.WATER_QUALITY)), (GRAPHICS.EFFECTS_QUALITY, options.GraphicSetting(GRAPHICS.EFFECTS_QUALITY)), (GRAPHICS.POST_PROCESSING_QUALITY, options.GraphicSetting(GRAPHICS.POST_PROCESSING_QUALITY)), (GRAPHICS.MOTION_BLUR_QUALITY, options.GraphicSetting(GRAPHICS.MOTION_BLUR_QUALITY)), (GRAPHICS.SNIPER_MODE_EFFECTS_QUALITY, options.GraphicSetting(GRAPHICS.SNIPER_MODE_EFFECTS_QUALITY)), (GRAPHICS.VEHICLE_DUST_ENABLED, options.GraphicSetting(GRAPHICS.VEHICLE_DUST_ENABLED)), (GRAPHICS.SNIPER_MODE_GRASS_ENABLED, options.GraphicSetting(GRAPHICS.SNIPER_MODE_GRASS_ENABLED)), (GRAPHICS.VEHICLE_TRACES_ENABLED, options.GraphicSetting(GRAPHICS.VEHICLE_TRACES_ENABLED)), (GRAPHICS.COLOR_GRADING_TECHNIQUE, options.GraphicSetting(GRAPHICS.COLOR_GRADING_TECHNIQUE)), (GRAPHICS.SEMITRANSPARENT_LEAVES_ENABLED, options.GraphicSetting(GRAPHICS.SEMITRANSPARENT_LEAVES_ENABLED)), (GRAPHICS.GRAPHICS_SETTINGS_LIST, options.ReadOnlySetting(lambda : graphics.GRAPHICS_SETTINGS.ALL())), (GRAPHICS.INTERFACE_SCALE, options.InterfaceScaleSetting(GRAPHICS.INTERFACE_SCALE)), (SOUND.MASTER_TOGGLE, options.SoundEnableSetting()), (SOUND.SOUND_QUALITY, options.SoundQualitySetting()), (SOUND.SOUND_QUALITY_VISIBLE, options.ReadOnlySetting(options.SoundQualitySetting.isAvailable)), (SOUND.MASTER, options.SoundSetting('master')), (SOUND.MUSIC, options.SoundSetting('music')), (SOUND.VEHICLES, options.SoundSetting('vehicles')), (SOUND.EFFECTS, options.SoundSetting('effects')), (SOUND.GUI, options.SoundSetting('gui')), (SOUND.AMBIENT, options.SoundSetting('ambient')), (SOUND.NATIONS_VOICES, options.AccountSetting('nationalVoices')), (SOUND.VOIP_MASTER_FADE, options.SoundSetting('masterFadeVivox')), (SOUND.VOIP_ENABLE, options.VOIPSetting(True)), (SOUND.VOIP_MASTER, options.VOIPMasterSoundSetting()), (SOUND.VOIP_MIC, options.VOIPMicSoundSetting(True)), (SOUND.CAPTURE_DEVICES, options.VOIPCaptureDevicesSetting()), (SOUND.VOIP_SUPPORTED, options.VOIPSupportSetting()), (SOUND.BASS_BOOST, options.BassBoostSetting()), (SOUND.DYNAMIC_RANGE, options.DynamicSoundPresetSetting(SOUND.DYNAMIC_RANGE, SOUND.DYNAMIC_RANGE)), (SOUND.SOUND_DEVICE, options.SoundDevicePresetSetting(SOUND.SOUND_DEVICE, SOUND.SOUND_DEVICE)), (SOUND.ALT_VOICES, options.AltVoicesSetting(SOUND.ALT_VOICES, storage=SOUND_SETTINGS_STORAGE)), (CONTROLS.MOUSE_ARCADE_SENS, options.MouseSensitivitySetting('arcade')), (CONTROLS.MOUSE_SNIPER_SENS, options.MouseSensitivitySetting('sniper')), (CONTROLS.MOUSE_STRATEGIC_SENS, options.MouseSensitivitySetting('strategic')), (CONTROLS.MOUSE_HORZ_INVERSION, options.MouseInversionSetting(CONTROLS.MOUSE_HORZ_INVERSION, 'horzInvert', storage=CONTROLS_SETTINGS_STORAGE)), (CONTROLS.MOUSE_VERT_INVERSION, options.MouseInversionSetting(CONTROLS.MOUSE_VERT_INVERSION, 'vertInvert', storage=CONTROLS_SETTINGS_STORAGE)), (CONTROLS.BACK_DRAFT_INVERSION, options.BackDraftInversionSetting(storage=CONTROLS_SETTINGS_STORAGE)), (CONTROLS.KEYBOARD, options.KeyboardSettings(storage=KEYBOARD_SETTINGS_STORAGE)), (CONTROLS.KEYBOARD_IMPORTANT_BINDS, options.ReadOnlySetting(lambda : options.KeyboardSettings.getKeyboardImportantBinds())), (AIM.ARCADE, options.AimSetting('arcade', storage=AIM_SETTINGS_STORAGE)), (AIM.SNIPER, options.AimSetting('sniper', storage=AIM_SETTINGS_STORAGE)), (MARKERS.ENEMY, options.VehicleMarkerSetting(MARKERS.ENEMY, storage=MARKERS_SETTINGS_STORAGE)), (MARKERS.DEAD, options.VehicleMarkerSetting(MARKERS.DEAD, storage=MARKERS_SETTINGS_STORAGE)), (MARKERS.ALLY, options.VehicleMarkerSetting(MARKERS.ALLY, storage=MARKERS_SETTINGS_STORAGE)), (OTHER.VIBRO_CONNECTED, options.ReadOnlySetting(lambda : VibroManager.g_instance.connect())), (OTHER.VIBRO_GAIN, options.VibroSetting('master')), (OTHER.VIBRO_ENGINE, options.VibroSetting('engine')), (OTHER.VIBRO_ACCELERATION, options.VibroSetting('acceleration')), (OTHER.VIBRO_SHOTS, options.VibroSetting('shots')), (OTHER.VIBRO_HITS, options.VibroSetting('hits')), (OTHER.VIBRO_COLLISIONS, options.VibroSetting('collisions')), (OTHER.VIBRO_DAMAGE, options.VibroSetting('damage')), (OTHER.VIBRO_GUI, options.VibroSetting('gui')), (TUTORIAL.CUSTOMIZATION, options.TutorialSetting(TUTORIAL.CUSTOMIZATION, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.TECHNICAL_MAINTENANCE, options.TutorialSetting(TUTORIAL.TECHNICAL_MAINTENANCE, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.PERSONAL_CASE, options.TutorialSetting(TUTORIAL.PERSONAL_CASE, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.RESEARCH, options.TutorialSetting(TUTORIAL.RESEARCH, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.RESEARCH_TREE, options.TutorialSetting(TUTORIAL.RESEARCH_TREE, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.MEDKIT_USED, options.TutorialSetting(TUTORIAL.MEDKIT_USED, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.REPAIRKIT_USED, options.TutorialSetting(TUTORIAL.REPAIRKIT_USED, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.FIRE_EXTINGUISHER_USED, options.TutorialSetting(TUTORIAL.FIRE_EXTINGUISHER_USED, storage=TUTORIAL_SETTINGS_STORAGE)), (TUTORIAL.WAS_QUESTS_TUTORIAL_STARTED, options.TutorialSetting(TUTORIAL.WAS_QUESTS_TUTORIAL_STARTED, storage=TUTORIAL_SETTINGS_STORAGE)))) self.__options.init() AccountSettings.onSettingsChanging += self.__onAccountSettingsChanging self.interfaceScale.init() def fini(self): self.options.dump() self.__storages = None if self.__options is not None: self.__options.fini() self.__options = None self.__serverSettings = None self.interfaceScale.fini() AccountSettings.onSettingsChanging -= self.__onAccountSettingsChanging AccountSettings.clearCache() LOG_DEBUG('SettingsCore is destroyed') return @property def options(self): return self.__options @property def storages(self): return self.__storages @property def serverSettings(self): return self.__serverSettings def packSettings(self, names): return self.__options.pack(names) def getSetting(self, name): return self.__options.getSetting(name).get() def getApplyMethod(self, diff): return self.__options.getApplyMethod(diff) def applySetting(self, key, value): if self.isSettingChanged(key, value): result = self.__options.getSetting(key).apply(value) from account_helpers.settings_core import settings_constants if key in settings_constants.GRAPHICS.ALL(): LOG_DEBUG('Apply graphic settings: ', {key: value}) self.onSettingsChanged({key: value}) return result else: return None def previewSetting(self, name, value): if self.isSettingChanged(name, value): self.__options.getSetting(name).preview(value) def applySettings(self, diff): self.__options.apply(diff) from account_helpers.settings_core import settings_constants graphicsSettings = {k:v for k, v in diff.iteritems() if k in settings_constants.GRAPHICS.ALL()} if graphicsSettings: LOG_DEBUG('Apply graphic settings: ', graphicsSettings) self.onSettingsChanged(graphicsSettings) def revertSettings(self): self.__options.revert() def isSettingChanged(self, name, value): return not self.__options.getSetting(name).isEqual(value) def applyStorages(self, restartApproved): confirmators = [] for storage in self.__storages.values(): confirmators.append(storage.apply(restartApproved)) return confirmators @process def confirmChanges(self, confirmators): yield lambda callback: callback(None) for confirmation, revert in confirmators: if confirmation is not None: isConfirmed = yield confirmation() if not isConfirmed: self.isChangesConfirmed = False revert() return def clearStorages(self): for storage in self.__storages.values(): storage.clear() def __onAccountSettingsChanging(self, key, value): LOG_DEBUG('Apply account setting: ', {key: value}) self.onSettingsChanged({key: value})
class ServerStats(Controller): STATS_REQUEST_TIMEOUT = 5.0 class TOOLTIP_TYPE: TYPE_UNAVAILABLE = ('unavailable', ) TYPE_CLUSTER = ('clusterCCU', ) TYPE_FULL = 'regionCCU/clusterCCU' onStatsReceived = Event.Event() def __init__(self, proxy): super(ServerStats, self).__init__(proxy) self.__statsCallbackID = None self.__stats = {} def onLobbyStarted(self, ctx): g_playerEvents.onServerStatsReceived += self.__onStatsReceived self.__loadStatsCallback(0.0) def onAvatarBecomePlayer(self): self.__stop() def onDisconnected(self): self.__stop() def getStats(self): return self.__stats def getFormattedStats(self): clusterCCU = self.__stats.get('clusterCCU', 0) regionCCU = self.__stats.get('regionCCU', 0) if regionCCU: clusterUsers = makeHtmlString( 'html_templates:lobby/serverStats', 'clusterName', {'count': BigWorld.wg_getIntegralFormat(clusterCCU)}) if clusterCCU == regionCCU: tooltipType = self.TOOLTIP_TYPE.TYPE_CLUSTER statsStr = clusterUsers else: tooltipType = self.TOOLTIP_TYPE.TYPE_FULL statsStr = '%s / %s' % ( clusterUsers, BigWorld.wg_getIntegralFormat(regionCCU)) else: tooltipType = self.TOOLTIP_TYPE.TYPE_UNAVAILABLE statsStr = '- / -' return (statsStr, tooltipType) def __stop(self): g_playerEvents.onServerStatsReceived -= self.__onStatsReceived self.__clearStatsCallback() def __onStatsReceived(self, stats): self.__stats = dict(stats) self.onStatsReceived(self.__stats) self.__loadStatsCallback() def __requestServerStats(self): self.__clearStatsCallback() if hasattr(BigWorld.player(), 'requestServerStats'): BigWorld.player().requestServerStats() def __loadStatsCallback(self, timeout=None): if constants.IS_SHOW_SERVER_STATS: self.__statsCallbackID = BigWorld.callback( timeout if timeout is not None else self.STATS_REQUEST_TIMEOUT, self.__requestServerStats) def __clearStatsCallback(self): if self.__statsCallbackID is not None: BigWorld.cancelCallback(self.__statsCallbackID) self.__statsCallbackID = None
def __init__(self, id, room): Entity.__init__(self, TYPE_MUC, id) self.room_jid = room self.eventMessage = Event.Event() self.eventUserOnline = Event.Event() self.eventUserOffline = Event.Event()
def run(self): event = Event.E_Init().Gen_Event() scheduler.enter(*event) while True: scheduler.run() print 'run out\n'
def __init__(self, width = 640, height = 480): self.init_sdl(width, height) BaseInterface.__init__(self) Event.register(Event.EVENT_QUIT, self.shutdown)
def __init__(self): self.onFocalPlaneChanged = Event.Event()
def __init__(self): super(MarathonEventsController, self).__init__() self.__eventManager = Event.EventManager() self.onFlagUpdateNotify = Event.Event(self.__eventManager) self.__marathons = [MarathonEvent(data) for data in MARATHONS_DATA]
def __init__(self): super(EventsNotificationsController, self).__init__() self.__eventMgr = Event.EventManager() self.onEventNotificationsChanged = Event.Event(self.__eventMgr)
class GameSessionController(IGameSessionController, Notifiable): NOTIFY_PERIOD = time_utils.ONE_HOUR TIME_RESERVE = 59 PLAY_TIME_LEFT_NOTIFY = time_utils.QUARTER_HOUR + TIME_RESERVE onClientNotify = Event.Event() onTimeTillBan = Event.Event() onNewDayNotify = Event.Event() onPremiumNotify = Event.Event() itemsCache = dependency.descriptor(IItemsCache) lobbyContext = dependency.descriptor(ILobbyContext) def init(self): self.addNotificators( PeriodicNotifier(self.__getClosestPremiumNotification, self.__notifyPremiumTime), PeriodicNotifier(lambda: self.NOTIFY_PERIOD, self.__notifyClient), PeriodicNotifier(self.__getClosestNewDayNotification, self.__notifyNewDay)) self.__sessionStartedAt = -1 self.__banCallback = None self.__lastBanMsg = None self.__curfewBlockTime = None self.__curfewUnblockTime = None self.__doNotifyInStart = False self.__battles = 0 LOG_DEBUG('GameSessionController::init') return def fini(self): LOG_DEBUG('GameSessionController::fini') self._stop() self.onClientNotify.clear() self.onTimeTillBan.clear() self.onNewDayNotify.clear() self.onPremiumNotify.clear() self.clearNotification() super(GameSessionController, self).fini() def onLobbyStarted(self, ctx): LOG_DEBUG('GameSessionController::start', self.__sessionStartedAt) self.__sessionStartedAt = ctx.get('sessionStartedAt', -1) self.__curfewBlockTime, self.__curfewUnblockTime = self.__getCurfewBlockTime( self._stats.restrictions) if self.__doNotifyInStart: self.__notifyClient() self.startNotification() self.__loadBanCallback() g_clientUpdateManager.addCallbacks({ 'account': self.__onAccountChanged, 'stats.restrictions': self.__onRestrictionsChanged, 'stats.playLimits': self.__onPlayLimitsChanged }) def onAvatarBecomePlayer(self): self._stop(doNotifyInStart=True) def onDisconnected(self): self._stop() def isSessionStartedThisDay(self): svrDaysCount = int(_getSvrLocal()) / time_utils.ONE_DAY clientDaysCount = int( self.__sessionStartedAt + self.__regionals().getDayStartingTime()) / time_utils.ONE_DAY return svrDaysCount == clientDaysCount def getDailyPlayTimeLeft(self): return self._stats.getDailyTimeLimits() - self._getDailyPlayHours() def getWeeklyPlayTimeLeft(self): return self._stats.getWeeklyTimeLimits() - self._getWeeklyPlayHours() @property def isParentControlEnabled(self): d, w = self._stats.getPlayTimeLimits() return d < time_utils.ONE_DAY or w < 7 * time_utils.ONE_DAY @property def isParentControlActive(self): playTimeLeft = min( [self.getDailyPlayTimeLeft(), self.getWeeklyPlayTimeLeft()]) parentControl = self.isParentControlEnabled and playTimeLeft <= self.PLAY_TIME_LEFT_NOTIFY notifyTime, _ = self.getCurfewBlockTime() banTimeLeft = min(*self.__getBlockTimeLeft()) curfewControl = self.__curfewBlockTime is not None and banTimeLeft <= self.PLAY_TIME_LEFT_NOTIFY return parentControl or curfewControl @property def sessionDuration(self): return _getSevUtc() - self.__sessionStartedAt @property def lastBanMsg(self): return self.__lastBanMsg @property def battlesCount(self): return self.__battles @property def isAdult(self): return self.__curfewBlockTime is None @property def isPlayTimeBlock(self): playTimeLeft, curfewTimeLeft = self.__getBlockTimeLeft() return playTimeLeft < curfewTimeLeft def incBattlesCounter(self): self.__battles += 1 def getCurfewBlockTime(self): if self.__curfewBlockTime is not None: blockTime = self.__curfewBlockTime - self.__regionals( ).getDayStartingTime() notifyStart = blockTime - self.PLAY_TIME_LEFT_NOTIFY else: notifyStart = blockTime = 0 return (_checkForNegative(notifyStart), _checkForNegative(blockTime)) def getParentControlNotificationMeta(self): from gui.Scaleform.daapi.view.dialogs import I18nInfoDialogMeta if self.isPlayTimeBlock: return I18nInfoDialogMeta('koreaPlayTimeNotification') else: notifyStartTime, blockTime = self.getCurfewBlockTime() def formatter(t): return time.strftime('%H:%M', time.localtime(t)) return I18nInfoDialogMeta('koreaParentNotification', messageCtx={ 'preBlockTime': formatter(notifyStartTime), 'blockTime': formatter(blockTime) }) @property def _stats(self): return self.itemsCache.items.stats def _stop(self, doNotifyInStart=False): LOG_DEBUG('GameSessionController::stop') self.stopNotification() self.__curfewBlockTime = None self.__curfewUnblockTime = None self.__sessionStartedAt = -1 self.__doNotifyInStart = doNotifyInStart self.__clearBanCallback() g_clientUpdateManager.removeObjectCallbacks(self) return def _getDailyPlayHours(self): if self.isSessionStartedThisDay(): offset = _getSevUtc() - self.__sessionStartedAt else: offset = _getSvrLocal() % time_utils.ONE_DAY return self._stats.todayPlayHours + offset def _getWeeklyPlayHours(self): regionals = self.__regionals() weekDaysCount = account_shared.currentWeekPlayDaysCount( _getSevUtc(), regionals.getDayStartingTime(), regionals.getWeekStartingDay()) return self._getDailyPlayHours() + sum( self._stats.dailyPlayHours[1:weekDaysCount]) def __regionals(self): return self.lobbyContext.getServerSettings().regionals @classmethod def __getClosestNewDayNotification(cls): return time_utils.ONE_DAY - _getSvrLocalToday() def __getClosestPremiumNotification(self): return time_utils.getTimeDeltaFromNow( time_utils.makeLocalServerTime(self._stats.premiumExpiryTime)) def __getBlockTimeLeft(self): playTimeLeft = min(self.getDailyPlayTimeLeft(), self.getWeeklyPlayTimeLeft()) if self.__curfewBlockTime is not None: curfewTimeLeft = self.__curfewBlockTime - _getSvrLocalToday() else: curfewTimeLeft = sys.maxint return (playTimeLeft, _checkForNegative(curfewTimeLeft)) def __loadBanCallback(self, banTimeLeft=0): self.__clearBanCallback() if not banTimeLeft: banTimeLeft = min( *self.__getBlockTimeLeft()) - self.PLAY_TIME_LEFT_NOTIFY banTimeLeft = max(banTimeLeft, 0) LOG_DEBUG('Game session block callback', banTimeLeft) if banTimeLeft: self.__banCallback = BigWorld.callback(banTimeLeft, self.__onBanNotifyHandler) def __clearBanCallback(self): if self.__banCallback is not None: BigWorld.cancelCallback(self.__banCallback) self.__banCallback = None return def __notifyClient(self): if self.isParentControlEnabled: playTimeLeft = min( [self.getDailyPlayTimeLeft(), self.getWeeklyPlayTimeLeft()]) playTimeLeft = max(playTimeLeft, 0) else: playTimeLeft = None self.onClientNotify(self.sessionDuration, time_utils.ONE_DAY - _getSvrLocalToday(), playTimeLeft) return def __notifyNewDay(self): self.onNewDayNotify(time_utils.ONE_DAY - _getSvrLocalToday()) def __notifyPremiumTime(self): stats = self._stats self.onPremiumNotify(stats.isPremium, stats.attributes, stats.premiumExpiryTime) def __onBanNotifyHandler(self): LOG_DEBUG('GameSessionController:__onBanNotifyHandler') banTime = time.strftime( '%H:%M', time.localtime(time.time() + self.PLAY_TIME_LEFT_NOTIFY)) self.__lastBanMsg = (self.isPlayTimeBlock, banTime) self.onTimeTillBan(*self.__lastBanMsg) self.__loadBanCallback() def __onAccountChanged(self, diff): if 'attrs' in diff or 'premiumExpiryTime' in diff: self.startNotification() stats = self._stats self.onPremiumNotify(stats.isPremium, stats.attributes, stats.premiumExpiryTime) def __onRestrictionsChanged(self, _): self.__curfewBlockTime, self.__curfewUnblockTime = self.__getCurfewBlockTime( self._stats.restrictions) self.__loadBanCallback() def __onPlayLimitsChanged(self, _): self.__loadBanCallback() @classmethod def __getCurfewBlockTime(cls, restrictions): if _BAN_RESTR in restrictions and len(restrictions[_BAN_RESTR]): _, ban = max(restrictions[_BAN_RESTR].items(), key=operator.itemgetter(0)) if ban.get( 'reason') == '#ban_reason:curfew_ban' and 'curfew' in ban: return (ban['curfew'].get('from', time_utils.ONE_DAY) + cls.TIME_RESERVE, ban['curfew'].get('to', time_utils.ONE_DAY)) return (None, None)
def __init__(self, setup): super(BattleFeedbackAdaptor, self).__init__() self.__arenaDP = weakref.proxy(setup.arenaDP) self.__arenaVisitor = weakref.proxy(setup.arenaVisitor) self.__visible = set() self.__pending = {} self.__attrs = {} self.__devInfo = {} self.__eventsCache = {} self.onPlayerFeedbackReceived = Event.Event() self.onPlayerSummaryFeedbackReceived = Event.Event() self.onPostmortemSummaryReceived = Event.Event() self.onVehicleMarkerAdded = Event.Event() self.onVehicleMarkerRemoved = Event.Event() self.onVehicleFeedbackReceived = Event.Event() self.onMinimapVehicleAdded = Event.Event() self.onMinimapVehicleRemoved = Event.Event() self.onMinimapFeedbackReceived = Event.Event() self.onDevelopmentInfoSet = Event.Event() self.onStaticMarkerAdded = Event.Event() self.onStaticMarkerRemoved = Event.Event() self.onRoundFinished = Event.Event() self.onShotDone = Event.Event()
def __init__(self): super(UserListModel, self).__init__() self.onUserSelectionChanged = Event.Event() self.onUserItemClicked = Event.Event()
def __init__(self): super(ContactsTreeComponent, self).__init__() self._mainDP = ContactsDataProvider() self.onListStateChanged = Event.Event() self.onGroupToggled = Event.Event()
def __init__(self): self.__flagModelFile = None self.__flagCircleModelFile = None self.__flagAnimAction = None self.__flags = {} self.__flagTeams = [] self.__resourcePoints = {} self.__rpGuids = {} self.__resourcePointsLock = None self.__delayedFlags = [] self.__evtManager = Event.EventManager() self.onFlagSpawning = Event.Event(self.__evtManager) self.onFlagSpawnedAtBase = Event.Event(self.__evtManager) self.onFlagCapturedByVehicle = Event.Event(self.__evtManager) self.onFlagDroppedToGround = Event.Event(self.__evtManager) self.onFlagAbsorbed = Event.Event(self.__evtManager) self.onFlagRemoved = Event.Event(self.__evtManager) self.onCarriedFlagsPositionUpdated = Event.Event(self.__evtManager) self.onFlagTeamsUpdated = Event.Event(self.__evtManager) self.onResPointIsFree = Event.Event(self.__evtManager) self.onResPointCooldown = Event.Event(self.__evtManager) self.onResPointCaptured = Event.Event(self.__evtManager) self.onResPointCapturedLocked = Event.Event(self.__evtManager) self.onResPointBlocked = Event.Event(self.__evtManager) self.onOwnVehicleInsideResPoint = Event.Event(self.__evtManager) self.onOwnVehicleLockedForResPoint = Event.Event(self.__evtManager) self.onResPointAmountChanged = Event.Event(self.__evtManager) self.onHideAll = Event.Event(self.__evtManager) self.__needHideAll = False flagModelParams = _g_ctfConfig.readModelParams(_FLAG_MODEL_NAME) if flagModelParams is not None: self.__flagModelFile = flagModelParams.get('file') self.__flagAnimAction = flagModelParams.get('action') flagCircleModelParams = _g_ctfConfig.readModelParams(_FLAG_CIRCLE_MODEL_NAME) if flagCircleModelParams is not None: self.__flagCircleModelFile = flagCircleModelParams.get('file') return
def __init__(self, account=None): self.__account = account self.__eManager = Event.EventManager() GlobalMapBase.__init__(self) self.__requestID = 0
class VoiceChatManager(VoiceChatManagerMeta): class PROVIDERS(CONST_CONTAINER): UNKNOWN = 'unknown' VIVOX = 'vivox' YY = 'YY' onPlayerSpeaking = Event.Event() onStateToggled = Event.Event() def __init__(self, app): super(VoiceChatManager, self).__init__() self.__app = app self.__failedEventRaised = False self.__callbacks = [] self.__captureDevicesCallbacks = [] self.__pendingMessage = None self.__enterToLobby = False return def __initResponse(self, _): self.__showChatInitSuccessMessage() while len(self.__callbacks): self.__callbacks.pop(0)(self.ready) def __captureDevicesResponse(self): devices = getVOIPManager().getCaptureDevices() while len(self.__captureDevicesCallbacks): self.__captureDevicesCallbacks.pop(0)(devices) def __showChatInitSuccessMessage(self): if GUI_SETTINGS.voiceChat and not BattleReplay.isPlaying(): if self.__failedEventRaised and self.ready: self.__failedEventRaised = False self.__pendingMessage = None if self.__enterToLobby: self.__showDialog('voiceChatInitSucceded') return def __showChatInitErrorMessage(self): if GUI_SETTINGS.voiceChat and not BattleReplay.isPlaying(): if not self.__failedEventRaised and not self.ready: self.__failedEventRaised = True if self.__enterToLobby: self.__showDialog('voiceChatInitFailed') else: self.__pendingMessage = 'voiceChatInitFailed' def _populate(self): super(VoiceChatManager, self)._populate() g_playerEvents.onAccountBecomePlayer += self.onAccountBecomePlayer self.__app.containerManager.onViewAddedToContainer += self.__onViewAddedToContainer voipMgr = getVOIPManager() voipMgr.onInitialized += self.__initResponse voipMgr.onFailedToConnect += self.checkForInitialization voipMgr.OnCaptureDevicesUpdated += self.__captureDevicesResponse voipMgr.onPlayerSpeaking += self.__onPlayerSpeaking voipMgr.onStateToggled += self.__onStateToggled def _dispose(self): self.__callbacks = None self.__captureDevicesCallbacks = None containerMgr = self.__app.containerManager if containerMgr: containerMgr.onViewAddedToContainer -= self.__onViewAddedToContainer voipMgr = getVOIPManager() voipMgr.onFailedToConnect -= self.checkForInitialization voipMgr.onPlayerSpeaking -= self.__onPlayerSpeaking voipMgr.onInitialized -= self.__initResponse voipMgr.OnCaptureDevicesUpdated -= self.__captureDevicesResponse voipMgr.onStateToggled -= self.__onStateToggled g_playerEvents.onAccountBecomePlayer -= self.onAccountBecomePlayer super(VoiceChatManager, self)._dispose() self.__app = None return def checkForInitialization(self, *args): self.__showChatInitErrorMessage() @property def state(self): return getVOIPManager().getState() @property def ready(self): return getVOIPManager().isInitialized() @process def onAccountBecomePlayer(self): yield self.initialize(BigWorld.player().serverSettings['voipDomain']) yield self.requestCaptureDevices(True) @async def initialize(self, domain, callback): if self.ready: vOIPSetting = g_settingsCore.options.getSetting('enableVoIP') vOIPSetting.initFromPref() callback(True) return if domain == '': LOG_WARNING('Initialize. Vivox is not supported') return self.__callbacks.append(callback) voipMgr = getVOIPManager() if voipMgr.isNotInitialized(): voipMgr.initialize(domain) vOIPSetting = g_settingsCore.options.getSetting('enableVoIP') vOIPSetting.initFromPref() @async def requestCaptureDevices(self, firstTime=False, callback=None): if getVOIPManager().getVOIPDomain() == '': LOG_WARNING('RequestCaptureDevices. Vivox is not supported') callback([]) return if not self.ready: LOG_WARNING( 'RequestCaptureDevices. Vivox has not been initialized') callback([]) return def resetCapturedDevice(devices, firstTime=firstTime): if firstTime: option = g_settingsCore.options.getSetting( SOUND.CAPTURE_DEVICES) option.apply(option.get(), firstTime) callback(devices) self.__captureDevicesCallbacks.append(resetCapturedDevice) getVOIPManager().requestCaptureDevices() def getPlayerDBID(self): p = BigWorld.player() if isPlayerAccount(): return p.databaseID elif isPlayerAvatar() and hasattr(p, 'playerVehicleID'): return p.arena.vehicles[p.playerVehicleID].get('accountDBID', None) else: return None def __onPlayerSpeaking(self, accountDBID, isSpeak): if not GUI_SETTINGS.voiceChat: return self.onPlayerSpeaking(accountDBID, bool(isSpeak)) self.as_onPlayerSpeakS(accountDBID, isSpeak, accountDBID == self.getPlayerDBID()) def __onStateToggled(self, isEnabled, _): if not GUI_SETTINGS.voiceChat: return self.onStateToggled(isEnabled) def isPlayerSpeaking(self, accountDBID): if GUI_SETTINGS.voiceChat: return bool(getVOIPManager().isParticipantTalking(accountDBID)) return False def isVivox(self): return getVOIPManager().getAPI() == VOIP_SUPPORTED_API.VIVOX def isYY(self): return getVOIPManager().getAPI() == VOIP_SUPPORTED_API.YY @property def provider(self): if self.isVivox(): return self.PROVIDERS.VIVOX if self.isYY(): return self.PROVIDERS.YY return self.PROVIDERS.UNKNOWN def isVOIPEnabled(self): return GUI_SETTINGS.voiceChat def __onViewAddedToContainer(self, _, pyView): settings = pyView.settings viewType = settings.type if viewType == ViewTypes.DEFAULT: viewAlias = settings.alias if viewAlias == VIEW_ALIAS.LOBBY: self.__enterToLobby = True if self.__pendingMessage is not None: self.__showDialog(self.__pendingMessage) self.__pendingMessage = None else: self.__enterToLobby = False return def __showDialog(self, key): DialogsInterface.showI18nInfoDialog(key, lambda result: None)
def __init__(self): super(ServerStats, self).__init__() self.__statsCallbackID = None self.__stats = {} self.onStatsReceived = Event.Event() return
elif cmd[0] == 'u' or cmd[0] == 'urgent': if scheduler.urgent(cmd[1]): print 'event ', cmd[1], 'is elevated to urgent.\n' else: print 'failed to elevated event ', cmd[1], ' to urgent.\n' elif cmd[0] == 'p' or cmd[0] == 'print': print 'Previous queue status:\n' i = 0 while i < len(scheduler._queue): print scheduler._queue[i] i += 1 elif cmd[0] == 'test': print 'Add a test event to queue\n' event = Event.E_Test().Gen_Event() scheduler.enter(*event) elif cmd[0] == 'oav1': print 'Add an offav event with default args to queue\n' event = Event.E_StartOffAV().Gen_Event() scheduler.enter(*event) elif cmd[0] == 'oav2': print 'Add an offav event with different args to queue\n' vm_profile = VM_Profile('instance-00000001', 'user-0002', 'host-0003') event = Event.E_StartOffAV([[ vm_profile, ], { 'avSoft': 'ClamAV',
class LoaderManager(LoaderManagerMeta): eManager = Event.EventManager() onViewLoadInit = Event.Event(eManager) onViewLoaded = Event.Event(eManager) onViewLoadError = Event.Event(eManager) def __init__(self, app): super(LoaderManager, self).__init__() self.__app = app self.__nameToLoadingItem = {} def loadView(self, alias, name, *args, **kwargs): return self.__doLoadView(alias, name, *args, **kwargs) def isViewLoading(self, viewAlias): result = False for item in self.__nameToLoadingItem.itervalues(): pyEntity = item.pyEntity if pyEntity and pyEntity.settings.alias == viewAlias: result = True break return result def viewLoaded(self, name, gfxEntity): if name in self.__nameToLoadingItem: item = self.__nameToLoadingItem.pop(name) pyEntity = g_entitiesFactories.initialize( item.pyEntity, gfxEntity, item.factoryIdx, extra={'name': item.name}) if pyEntity is not None: self.onViewLoaded(pyEntity) else: LOG_ERROR('Error during until DAAPI initializing.') else: LOG_ERROR('View load for name has no associated data', name) def viewLoadError(self, alias, name, errorTxt): msg = 'Error during view {0} load. Name: {1}, error:{2}' msg = msg.format(alias, name, errorTxt) LOG_ERROR(msg) item = None if name in self.__nameToLoadingItem: item = self.__nameToLoadingItem.pop(name) self.onViewLoadError(name, msg, item) if item is not None: settings = item.pyEntity.settings if constants.IS_DEVELOPMENT and settings.url != NO_IMPL_URL: g_entitiesFactories.addSettings( ViewSettings(NO_IMPL_ALIAS, View, NO_IMPL_URL, settings.type, None, ScopeTemplates.DEFAULT_SCOPE)) LOG_WARNING('Try to load noImpl swf...') self.__doLoadView(NO_IMPL_ALIAS, item.name) def cancelLoadingByName(self, name): if name in self.__nameToLoadingItem: self.__nameToLoadingItem.pop(name) def viewInitializationError(self, config, alias, name): msg = "View '{0}' does not implement net.wg.infrastructure.interfaces.IView" msg = msg.format(alias) LOG_ERROR(msg) item = None if name in self.__nameToLoadingItem: item = self.__nameToLoadingItem.pop(name) pyEntity = item.pyEntity pyEntity.destroy() self.onViewLoadError(name, msg, item) def _dispose(self): self.__app = None self.__nameToLoadingItem.clear() self.eManager.clear() super(LoaderManager, self)._dispose() def __doLoadView(self, alias, name, *args, **kwargs): viewTutorialID = self.__app.tutorialManager.getViewTutorialID(alias) if name in self.__nameToLoadingItem: item = self.__nameToLoadingItem[name] self.as_loadViewS(item.pyEntity.settings._asdict(), alias, name, viewTutorialID) return item.pyEntity else: pyEntity, factoryIdx = g_entitiesFactories.factory( alias, *args, **kwargs) if pyEntity is not None: pyEntity.setUniqueName(name) pyEntity.seEnvironment(self.__app) self.__nameToLoadingItem[name] = _LoadingItem( name, pyEntity, factoryIdx, args, kwargs) self.onViewLoadInit(pyEntity) self.as_loadViewS(pyEntity.settings._asdict(), alias, name, viewTutorialID) return pyEntity LOG_WARNING('PyEntity for alias %s is None' % alias) return
def __init__(self, connection, clan_conference): Entity.__init__(self, connection, TYPE_SESSION) self.clan_conference = clan_conference self.eventMessage = Event.Event() self.eventFriendOnline = Event.Event() self.eventFriendOffline = Event.Event()
def __init__(self): self.onTimeWarpStart = Event.Event() self.onTimeWarpFinish = Event.Event() self.onPause = Event.Event() self.onMuteSound = Event.Event() self.onWatcherNotify = Event.Event()
def __init__(self): self.__space = None self.__videoCameraController = HangarVideoCameraController() self.__inited = False self.__spaceInited = False self.__isModelLoaded = False self.__isSpacePremium = False self.__igrSpaceType = constants.IGR_TYPE.NONE self.__delayedIsPremium = False self.__delayedForceRefresh = False self.__delayedRefreshCallback = None self.__spaceDestroyedDuringLoad = False self.__lastUpdatedVehicle = None self.onSpaceRefresh = Event.Event() self.onSpaceRefreshCompleted = Event.Event() self.onSpaceCreating = Event.Event() self.onSpaceCreate = Event.Event() self.onSpaceDestroy = Event.Event() self.onSpaceChanged = Event.Event() self.onMouseEnter = Event.Event() self.onMouseExit = Event.Event() self.onMouseDown = Event.Event() self.onMouseUp = Event.Event() self.onHeroTankReady = Event.Event() self.onVehicleChanged = Event.Event() self.onVehicleChangeStarted = Event.Event() self.onSpaceChangedByAction = Event.Event() self.onNotifyCursorOver3dScene = Event.Event() self.__isCursorOver3DScene = False return