class CountryInfoBox(Box): def __init__(self, gameWindow): super(CountryInfoBox, self).__init__() self.gameWindow = gameWindow layout = QGridLayout(self) layout.setSpacing(0) layout.setContentsMargins(0, 0, 0, 0) self.img = QLabel() self.info = Info() self.info.textTemplate = '%s' layout.addWidget(self.img, 0, 0, Qt.AlignHCenter) layout.addWidget(self.info, 1, 0, Qt.AlignHCenter) self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)]) def updateCountry(self, country): gameView = self.gameWindow.gameView.gameView playerName = 'Neutral' weapon = 0 for player in self.gameWindow.game.players: if player.id == gameView.gameMap.owner[country]: playerName = player.name weapon = player.weapon image = gameView.countries[country].normal self.img.setPixmap(QPixmap(image)) if len(playerName) > 10: playerName = playerName[:7] + '...' else: playerName = playerName + ' ' * (10 - len(playerName)) info = [('Owner', playerName), ('Weapon', str(int(weapon))), ('Defense', str(gameView.gameMap.defense[country])), ('Area', str(gameView.gameMap.area[country]))] self.info.updateInfo(info)
def reply(self, data, cb): info = data if not isinstance(data, Info): info = Info(data) if not self.config.get('keepBlank', False) and info.text: info.text = info.text.trim() rule_list = self.routes waiter = self.wait_rules.get(info.user, None) if waiter: rule_list = [].extend(waiter).extend(self.routes) self.last_wait_rules[info.user] = waiter self.wait_rules[info.user] = None for i in range(0, len(rule_list)): rule = rule_list[i] if Rule.is_match(info, rule): weixinlogger.info("match %s" % rule.name) conversationlogger.info("match %s" % rule.name) rule.count = i result = Rule.execute(info, rule, cb) if isinstance(result, (str, unicode)): result = BuildConfig(MessageBuilder.TYPE_RAW_TEXT, None, result) if result: if rule.replies: self.wait(info.user, Rule.convert(rule.replies, rule.name)) return cb(None, result) else: logger.debug("not match %s" % rule.name) return cb('404', BuildConfig(MessageBuilder.TYPE_RAW_TEXT, None, self.get_status('404') + info.text))
def __init__(self, bam, bed, info, out, analytical_threshold=ANALYTICAL_THRESHOLD): self.bam = bam self.bed = bed self.info = info self.out = out self.analytical_threshold = analytical_threshold # Init self.bed_obj = Bed(self.bed) self.info_obj = Info(self.info) self.mh_dict = {} self.filters_obj = Filters( analytical_threshold=self.analytical_threshold, abs_analytical_threshold=self.ABSOLUTE_ANALYTICAL_THRESHOLD, min_mapq=self.MIN_MAPPING_QUALITY, max_mapq=self.MAX_MAPPING_QUALITY, remove_deletions=self.REMOVE_DELETIONS) self.short_reads_count = 0 self.total_reads_count = 0 self.number_of_contributors_overall = 0
def updateuser(username, userright, userwrong, usertimeduring, userchoicelog): userid = db.session.query( User.user_id).filter(User.user_username == username).first() if userid: userid = userid[0] lastlog = db.session.query(UserLog).filter( and_(UserLog.userlog_userid == userid, UserLog.userlog_status == 0)).first() if lastlog: db.session.query(UserLog).filter( UserLog.userlog_userid == userid, ).update( {"userlog_status": 1}) userlog_userid = userid userlog_right = userright userlog_wrong = userwrong userlog_timeduring = usertimeduring userlog_status = 0 userlog_choicelog = userchoicelog ul = UserLog(userlog_userid, userlog_right, userlog_wrong, userlog_timeduring, userlog_status, userlog_choicelog) try: db.session.add(ul) db.session.commit() except Exception as e: print(e) return Info(False, "考试数据提交失败,请联系系统管理员!(" + str(userlog_choicelog) + ")").todict() else: return Info(True, "考试数据提交成功", { "userlog_timeduring": userlog_timeduring }).todict() else: return Info(False, "非法的用户名").todict()
def rozdaj_karty(self): Info.rozdanie_kart() for x in range(2): for gracz in self.gracze: i = randint(0, len(self.talia)-1) gracz.reka.dobierz(self.talia[i]) self.talia.pop(i)
def run(self): try: self._prepare.create_folder() StepTimes().add( 'preparation_start' ) # TODO writes to old directory because does not exist yet Info().status = "preperation_start" self._prepare.execute() logging.info('End of Preparation') #StepTimes().add('preparation_start') StepTimes().add('simulation_start') logging.info('Start of simulation') self._system_monitor.start() self._event.execute( timeout=25) # TODO check if timeout works as expected self._system_monitor.exit() logging.info('End of simulation') StepTimes().add('postprocessing_start') self._postprocessing.execute() StepTimes().add('postprocessing_end') except Exception as exce: Info().status = f"failed with {exce}" self._postprocessing.clean_up_docker_safe() raise exce
def main(): output_type = "brief" # default #Print the welcome message: print("Welcome to this searcher!") print("To quit, please enter ::quit") conn = Connection() conn.connect() cursors = conn.get_cursors() quit = False while not quit: query = input("(Searcher)>>> ").lower() if query == "::quit": print("Thank you for using our service") conn.close() break elif query == "output=breif": output_type = "brief" elif query == "output=full": output_type = "full" else: try: info = Info(query, cursors, output_type) info.execute_query() except Exception: print("No matches found!")
def __init__(self): # initializes game session and builds game resourses pygame.init() self.settings = Settings() # storing game statistics self.stats = Stats(self) self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) self.screen_rect = self.screen.get_rect() self.settings.screen_width = self.screen.get_rect().width self.settings.screen_height = self.screen.get_rect().height pygame.display.set_caption("Warplanes") self.bg_color = self.settings.bg_colour self.hp = self.settings.enemy_hp self.junkers = Junkers(self) self.shots = pygame.sprite.Group() self.enemy_shots = pygame.sprite.Group() self.enemies = pygame.sprite.Group() # game scoreboard self.sb = Scoreboard(self) self.play_button = Button(self, "START", (0, -100)) self.info_button = Button(self, "INFO", (0, 100)) self.pause_button = Button(self, "Continue") self._create_sky() self.info = Info(self) pygame.mixer.music.load('music.wav') self.shot_sound = pygame.mixer.Sound('shot.ogg') self.explosion_sound = pygame.mixer.Sound('explosion.ogg')
def OneCnn(): brain = Brain() brain = brain.getInstance('cnn', 'log/cat_vs_dog/train/') from info import Info info = Info() image_info = info.getOneImage('data/cat_vs_dog/test/dog.9712.jpg') brain.evaluateOneImage(image_info, 2, {'cat': 0, 'dog': 1})
def trainCnn(): brain = Brain() brain = brain.getInstance('cnn', 'log/cat_vs_dog/train/') train_dir = 'data/cat_vs_dog/train/' from info import Info info = Info() train_batch, train_label_batch = info.getImages(train_dir, {'cat' : 0, 'dog' : 1}) brain.trainCnnNetwork(train_batch, train_label_batch)
def selected(self): items = self.tableWidget.selectedItems() if not items: return self.tableWidget.clearSelection() self.inf = Info(items[0].data(QtCore.Qt.UserRole)) self.inf.show()
def entrust(self): """委托单 委托状态:已报、部成、已报待撤、部成待撤、未报、待报、已成、已撤、部撤、废单 """ info = Info('entrust', self.broker) information = self.user.entrust() info.format(information) return info
def initstudents(): try: db.session.query(UserLog).update({"userlog_status": 1}) db.session.commit() except Exception as e: print(e) return Info(False, "初始化失败!" + str(e)).todict() else: return Info(True, "初始化成功!").todict()
def __init__(self, event_id, log_level, when, who, do_what, what, how_much, with_whom): Info.__init__(self, event_id, self.__class__.__name__) self.log_level = log_level self.when = when self.who = who self.do_what = do_what self.what = what self.how_much = how_much self.with_whom = with_whom
def check_available_cancels(self, parsed=True): """ @Contact: Emptyset <*****@*****.**> 检查撤单列表 """ info = Info('entrust', self.broker) information = self.user.check_available_cancels(parsed) info.format(information) return info
def removeproblems(problem_id): pr = db.session.query(Problem).filter( Problem.problem_id == problem_id).first() if pr: db.session.delete(pr) db.session.commit() return Info(True, "删除成功!").todict() else: return Info(False, "不存在的题号!").todict()
def __init__(self): self.window = Tk() self.window.protocol("WM_DELETE_WINDOW", self.finishApp) self.window.title('Herramienta de prueba para la predicción') ico = PhotoImage(file=os.path.abspath('.') + '/Activos/term.png') self.window.call('wm', 'iconphoto', self.window._w, ico) self.window.config(bg=mainColor) self.window.attributes("-zoomed", False) self.window.minsize(width=300, height=300) #Peso 100% en self.window self.window.grid_rowconfigure(0, weight=1) self.window.grid_columnconfigure(0, weight=1) #Ventana principal fija sin ajuste de tamaño self.window.resizable(False, False) #Centrar ventana en función de las dimendsiones del contenedor de inicio self.center(450, 490) self.view = Window(self.window) self.functions = Functions() self.infoW = Info(self.view.dataContainer) self.genDataW = GenData(self.view.dataContainer) self.predW = Predictions(self.view.dataContainer) self.graphsW = Graphs(self.view.dataContainer) #Botones de las acciones del usuario self.view.buttonDisconnect.bind("<Button>", self.disconnect) self.view.buttonToBD.bind("<Button>", self.changeToConnect) self.view.buttonConnect.bind("<Button>", self.checkConnection) self.view.infoButton.bind( "<Button>", lambda event: self.switchSelector( self.view.predButton, self.view.graphButton, self.view. genDataButton, self.view.infoButton, 1)) self.view.genDataButton.bind( "<Button>", lambda event: self.switchSelector( self.view.infoButton, self.view.predButton, self.view. graphButton, self.view.genDataButton, 2)) self.view.predButton.bind( "<Button>", lambda event: self.switchSelector( self.view.infoButton, self.view.graphButton, self.view. genDataButton, self.view.predButton, 3)) self.view.graphButton.bind( "<Button>", lambda event: self.switchSelector( self.view.infoButton, self.view.genDataButton, self.view. predButton, self.view.graphButton, 4)) self.genDataW.buttonFilterData.bind("<Button>", lambda event: self.getNewGenData()) self.graphsW.buttonGetGraph.bind("<Button>", lambda event: self.getGraphsData()) self.predW.buttonForecast.bind("<Button>", self.getForecast) self.predW.butHistForecast.bind("<Button>", self.getHistForecast) #Ventana principal actualizaciones self.window.mainloop()
def studentregitster(username, password): us = db.session.query(User).filter( User.user_username == username, ).first() if us: return Info(False, "已存在的用户名!").todict() else: user = User(username, password) db.session.add(user) db.session.commit() return Info(True, "注册成功!").todict()
def cancel_all_entrust(self): """ 撤单所有委托 """ #if 'ht' != self.broker: # return False info = Info('cancel', self.broker) information = self.user.cancel_all_entrust() info.format(information) return info
def __init__(self): bot_name = "Swarming" self.game = hlt.Game(bot_name) logging.info("Starting bot {}".format(bot_name)) self.pathfinder = Pathfinder() self.info = Info() self.ai = AI(self.info, self.pathfinder) self.game_map = None
def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ super(MainWindow, self).__init__(parent) self.setupUi(self) self.info = Info()
def get_port_list(sheet): port_list = [] pattern = re.compile('\d+') s = Info("Get Ports list") for port in sheet.iter_rows(2, sheet.max_row): str = port[3].value p = re.match(pattern, str) port_list.append(p.group(0)) # print(p.group(0)) s.out_end() return port_list
def __init__(self, gameWindow): super(CountryInfoBox, self).__init__() self.gameWindow = gameWindow layout = QGridLayout(self) layout.setSpacing(0) layout.setContentsMargins(0, 0, 0, 0) self.img = QLabel() self.info = Info() self.info.textTemplate = '%s' layout.addWidget(self.img, 0, 0, Qt.AlignHCenter) layout.addWidget(self.info, 1, 0, Qt.AlignHCenter) self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)])
def cancel_entrust(self, entrust_no, stock_code = ''): """撤单 :param entrust_no: 委托单号 """ info = Info('cancel', self.broker) if self.broker == 'yh': information = self.user.cancel_entrust(entrust_no, stock_code) elif self.broker == 'xq': #xueqiu cancel 接口不可用 information = self.user.cancel_entrust(entrust_no, stock_code) info.format(information) return info
def modifypassword(oldpassword, newpassword, username): ad = db.session.query(Admin).filter( and_(Admin.admin_username == username, Admin.admin_password == oldpassword)).first() if not ad: return Info(False, "原密码错误!").todict() else: db.session.query(Admin).filter( Admin.admin_username == username).update( {"admin_password": newpassword}) db.session.commit() return Info(True, "密码修改成功!").todict()
def _make_info(self): if self._info is None: self._info = Info() self._copy_style_from_view([self._info, self._info.text_view]) self._info_revealer.add(self._info) self._info.show() self._info_revealer.show() self._info_revealer.set_reveal_child(True) self._info.connect('destroy', self._on_info_destroy)
def load_data(self, info: Info, csv_path: str, encoding: str): print("Завантажуємо основний файл") arr2 = [] try: with open(csv_path, newline='', encoding=encoding) as f: reader = csv.reader(f) for row in reader: curr_row = row[0].split(';') arr2.extend([curr_row]) info.set_information(arr2) print("input-csv <" + csv_path + ">: OK") except Exception: print("***** program aborted *****") print("Problem in load data")
def main(): try: info = Info() time.sleep(1) info.retrieve_info() except EOFError: print("\nRun this Docker image with -it!") sys.exit(-2) except KeyboardInterrupt: print("\nControl + C has been invoked!") sys.exit(-3) except Exception: print("\nSomething went wrong!") sys.exit(-1)
def get_deal(self, date=None): """ @Contact: Emptyset <*****@*****.**> 获取历史日成交列表 e.g.: get_deal( "2016-07-14" ) 如果不传递日期则取的是当天成交列表 返回值格式与get_current_deal相同 遇到提示“系统超时请重新登录”或者https返回状态码非200或者其他异常情况会返回False """ c = Checker() info = Info('deal', self.broker) information = self.user.get_deal(date) info.format(information) return info
def wybor(self): print( "-----------------------------------------------------------------" ) bet = "ALL-IN" if self.rozdanie.najwiekszy_zaklad >= self.zaklad + self.saldo else "BET" wybor_flag = False while not wybor_flag: Info.wyswietl_karty_gracza(self) akcja = input( f" PASS || ALL || BET *kwota* \t or \t P || A || B *kwota*\n \t" ).upper() if akcja == "PASS" or akcja == "P": self.passuje = True wybor_flag = True ### ERROR GDY SIE NIE PODA LICZBY, INPUT TYPU 9-1 DAJE LICZBE 91 ### elif akcja[0] == "B" or akcja[0:3] == "BET": # Zamienia na ladna liczbe wartosc = int("".join([str(x) for x in akcja if x.isdigit()])) if self.rozdanie.najwiekszy_zaklad > wartosc: Info.minimalna_stawka_error( self.rozdanie.najwiekszy_zaklad) else: if self.bet(wartosc): wybor_flag = True else: Info.za_maly_budzet() elif akcja == "ALL" or akcja == "A" or akcja == "ALL-IN": self.bet(self.saldo + self.zaklad) self.all_in = True wybor_flag = True else: Info.zla_akcja() print("\n")
def setsuccessjson(param): if 'code' and 'data' in param: code = param['code'] param = param['data'] info = Info() response = { 'status': code, 'meta': info.get(), 'result': param } return response return { 'status': 500, 'message': 'Something went wrong!!' }
def __init__(self, name): # Note that the below condition should fail if this __ini__ condition is called from a derived class, as self.__class__.__name__ should be the daughter class name! if self.__class__.__name__ == "Events": AdvPrint.cerr_exit("Internal error: Instance of abstract base class 'Events' created!") self.name = name Info.book_events(self) # sets identifier self.processed = False self.analysis_result_files = dict() self.analysis_signal_files = dict() self.analysis_cutflow_files = dict() self.maxEvents = -1 self.result_output_file = "" self.fritz_config_file = ""
def get_resultCollectors(self): """ Gathers results from all events""" # setup resultCollector object resultCollectors_pr = dict() for analysis in Info.analyses: resultCollectors_pr[analysis] = dict() signal_regions = Info.get_analysis_parameters(analysis)["signal_regions"] for sr in signal_regions: resultCollectors_pr[analysis][sr] = ResultCollector(self.name, analysis, sr) # loop over all associated events and average results in all resultCollectors for event in self.eventsList: resultCollectors_ev = event.get_resultCollectors() for analysis in resultCollectors_pr: for sr in resultCollectors_pr[analysis]: resultCollectors_pr[analysis][sr].add_and_average(resultCollectors_ev[analysis][sr]) # Write process file, if wanted if Info.parameters["ProcessResultFileColumns"] != []: AdvPrint.mute() AdvPrint.set_cout_file(self.result_output_file, True) for col in Info.parameters["ProcessResultFileColumns"]: AdvPrint.cout(col+" ", "nlb") AdvPrint.cout("") for a in sorted(resultCollectors_pr.keys()): for sr in sorted(resultCollectors_pr[a].keys()): AdvPrint.cout(resultCollectors_pr[a][sr].line_from_data(Info.parameters["ProcessResultFileColumns"])) AdvPrint.format_columnated_file(self.result_output_file) AdvPrint.set_cout_file("#None") AdvPrint.unmute() return resultCollectors_pr
def prepare_run(self): """Creates all output folders and files and generate cards that are needed""" Info.prepare_config() # preparation only needed if new run is started with "overwrite" DetectorSettings.merge_settings() if Info.parameters["outputexists"] == "overwrite" or not os.path.isdir(Info.paths['output']): Info.prepare_output_directories() DetectorSettings.update_delphes_files() else: # If the original run used modified Delphes settings, we need them for the added run as well atlas_conf_new = os.path.join(Info.paths['output_delphes'], "modified_ATLAS_card.tcl") cms_conf_new = os.path.join(Info.paths['output_delphes'], "modified_CMS_card.tcl") if os.path.isfile(atlas_conf_new): Info.files['delphes_global_config_ATLAS'] = atlas_conf_new if os.path.isfile(cms_conf_new): Info.files['delphes_global_config_CMS'] = cms_conf_new
def linkAnalysis(self,link): temp=link.find("a") address=temp["href"] brief=temp["title"] print 'link address is : ',address # print 'link content is :', brief timenow=link.find(attrs={"class":"date"}).string # print timenow y=timenow[0:4] m=timenow[5:7] d=timenow[8:10] second=timenow[12:20] timenow=y+'-'+m+'-'+d+' '+second # print timenow now= time.strptime(timenow, '%Y-%m-%d %H:%M:%S') if time.mktime(now)<time.mktime(self.updateTime): return 0 childSoup=self.getChildSoup(address) try: newsContent=childSoup.find(attrs={"class":"art_main"}) except: newsContent=None stringTemp="" if not newsContent: return 1 for content in newsContent: stringTemp+=str(content) # print stringTemp # print searchdict tags=self.searchTag(stringTemp) # print 'tags is ',tags if tags: newin=Info() newin.addLink(address,brief) for tag in tags: newin.addTag(tag) print 'in this news find ',tag self.addInfo(newin) print '------------------------- one link analysis end ','------------------' return 1
def prepareFritzInputFile(self, config, events): config, secname = events.prepareFritzInputFile(config) # if cross section is provided, override config if self.have_xsect: config.set(secname, "xsect", str(self.xsec*Info.unit(self.xsec_unit))) if self.have_xerr: if self.xerr_unit == "%": config.set(secname, "xsectErrFactor", str(self.xerr/100.)) else: config.set(secname, "xsectErr", str(self.xerr*Info.unit(self.xerr_unit))) else: # fritz wants this, lets give it to him config.set(secname, "xsectErr", str(0)) if self.have_kfac: config.set(secname, "kfactor", str(self.kfac)) return config
def linkAnalysis(self,link): temp=link.findAll("a") dat=link.findAll("span") i=0 for da in dat: strtemp=da.string if strtemp.find(':')==-1: return else: address='http://stock.cfi.cn/'+temp[i]["href"] brief=temp[i].string t=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())) truetime=t[0:11]+strtemp+':59' now= time.strptime(truetime, '%Y-%m-%d %H:%M:%S') if time.mktime(now)<time.mktime(self.updateTime): return else : print 'link address is : ',address childSoup=self.getChildSoup(address) try: newsContent=childSoup.find(attrs={"id":"tdcontent"}) except: newsContent=None stringTemp="" if not newsContent: return for content in newsContent: stringTemp+=str(content) tags=self.searchTag(stringTemp) if tags: newin=Info() newin.addLink(address,brief) for tag in tags: newin.addTag(tag) print 'in this news find ',tag self.addInfo(newin) print '------------------------- one link analysis end ','------------------' i+=1
def drawSprites(): global mushrooms, ploppers, snakes, spiders, gamePaused, gamePlaying for f in range(len(mushrooms)): mushrooms[f].draw(window) for f in range(len(ploppers)): ploppers[f].draw(window) if gamePlaying: player.draw(window) for f in range(len(snakes)): snakes[f].draw(window) for f in range(len(spiders)): spiders[f].draw(window, fontSmaller) if gamePaused: gamePaused = Info(130, 280, pygame.image.load(os.path.join("centipede", "paused.png"))) gamePaused.draw(window)
def __init__(self): #global Info, AdvPrint """ Initialisation of a CheckMATE object leads to an entire run of the CheckMATE procedure""" # Initialisation steps #Info.init() Info.fill_standard_paths_and_files() if len(sys.argv) == 1: self.printUsage() self.printLogo() if len(sys.argv) == 2 and sys.argv[-1] != "-h": Info.fill_info_from_file(sys.argv[1]) self.procList = Info.fill_processes_from_file(sys.argv[1]) else: Info.fill_info_from_parameters() self.procList = Info.fill_processes_from_parameters() if Info.parameters["outputexists"] == "add": self.load(Info.files['internal_processes']) for p in self.procList: p.checkInputConsistency() self.user_param_check() self.prepare_run() # Running the event-based part if self.procList == []: AdvPrint.cerr_exit("No processes are loaded!") for p in self.procList: p.prepare() p.run() AdvPrint.cout("\n") # Evaluate if not Info.flags['skipevaluation']: self.evaluate() # Store internal status Info.save(Info.files['internal_info']) self.save(Info.files['internal_processes'])
def linkAnalysis(self,link): temp=link.find("a") address=temp["href"] brief=temp["title"] timenow=link.find("span").string timenow+=":59" now= time.strptime(timenow, '%Y-%m-%d %H:%M:%S') # print 'news time:',timenow,'and last update time :',self.updateTime if time.mktime(now)<time.mktime(self.updateTime): return 0 print 'link address is : ',address childSoup=self.getChildSoup(address) try: newsContent=childSoup.find(attrs={"class":"Body","id":"ContentBody"}) except: newsContent=None stringTemp="" if newsContent==None: return 1 for content in newsContent: stringTemp+=str(content) tags=self.searchTag(stringTemp) if tags: newin=Info() newin.addLink(address,brief) for tag in tags: newin.addTag(tag) print 'in this news find ',tag self.addInfo(newin) print '------------------------- one link analysis end -------------------------' return 1
def prepareFritzInputFile(self, fritzconfig): fritzconfig, secname = Pythia8Events.prepareFritzInputFile(self, fritzconfig) if Info.files['py8rndm'] != '': fritzconfig.set(secname,"rndmIn",Info.files['py8rndm']) fritzconfig.set(secname, "useMG5","true") fritzconfig.set(secname, "mgProcCard",self.mg5_cards["proc"]) if self.mg5_cards["run"] != "" : fritzconfig.set(secname, "mgRunCard",self.mg5_cards["run"]) if self.mg5_cards["param"] != "" : fritzconfig.set(secname, "mgParamCard",self.mg5_cards["param"]) if self.mg5_cards["config"] != "" : fritzconfig.set(secname, "mgConfigCard",self.mg5_cards["config"]) fritzconfig.set(secname, "mgRunPath",os.path.join(Info.paths['output_mg5'], self.identifier)) fritzconfig.set(secname, "mgSourcePath",Info.paths['mg5_source_path']) if self.have_xsth: fritzconfig.set(secname, "xsectthresh",self.xsth*Info.unit(self.xsth_unit)/Info.unit('pb')) # pythia calculates in pb return fritzconfig, secname
def get_resultCollectors(self): """ Finds the results of all events within all processes and sums and averages them """ #setup resultCollector object resultCollectors_tot = dict() for analysis in Info.analyses: resultCollectors_tot[analysis] = dict() signal_regions = Info.get_analysis_parameters(analysis)["signal_regions"] for sr in signal_regions: resultCollectors_tot[analysis][sr] = ResultCollector("total", analysis, sr) # loop over all associated processes for proc in self.procList: # process results are summed resultCollectors_proc = proc.get_resultCollectors() for analysis in resultCollectors_tot: for sr in resultCollectors_tot[analysis]: resultCollectors_tot[analysis][sr].add_and_sum(resultCollectors_proc[analysis][sr]) return resultCollectors_tot
def _config_experiment(config, experiment): exists = False # are there any analyses for this experiment? parameters = dict() for analysis in Info.analyses: params = Info.get_analysis_parameters(analysis) if params["experiment"] != experiment: continue exists = True parameters[analysis] = params section_name = _analysis_section_name(analysis) config.add_section(section_name) config.set(section_name, "analysishandler", experiment) if not exists: # no analyses found. return _filter_jettags(config, parameters, experiment, experiment) _filter_isolation(config, parameters, "electron", "ELECTRONISO", experiment, experiment) _filter_isolation(config, parameters, "muon", "MUONISO", experiment, experiment) _filter_isolation(config, parameters, "photon", "PHOTONISO", experiment, experiment)
def load_expdata(self): analysis = self.resultCollector.analysis if analysis == "": return # for pseudo-evaluators sr = self.resultCollector.sr parameters = Info.get_analysis_parameters(analysis) # S95 comparison: r value compares lower s95 limit on s (which is almost 2 sigma) to the model independent limit if sr not in parameters["reference_data"]: AdvPrint.cerr_exit("evaluator::load_expdata unknown signal region "+analysis+" - "+sr) if "S95_obs" not in parameters["reference_data"][sr]: AdvPrint.cerr_exit("evaluator::load_expdata S95_obs value is unknown for "+analysis+" - "+sr) self.s95_obs = float(parameters["reference_data"][sr]["S95_obs"]) # If no expected upper limit is given, observed limit is used if "S95_exp" not in parameters["reference_data"][sr]: self.s95_exp = self.s95_obs self.warnings.append("No expected limit could be found in reference data. Using expected = observed.") else: self.s95_exp = float(parameters["reference_data"][sr]["S95_exp"]) if "obs" not in parameters["reference_data"][sr]: AdvPrint.cerr_exit("evaluator::load_expdata 'obs' is unknown for "+analysis+" - "+sr) self.obs = float(parameters["reference_data"][sr]["obs"]) if "bkg" not in parameters["reference_data"][sr]: AdvPrint.cerr_exit("evaluator::load_expdata 'bkg' is unknown for "+analysis+" - "+sr) self.bkg = float(parameters["reference_data"][sr]["bkg"]) self.bkg_err = -1 if "bkg_err" in parameters["reference_data"][sr]: self.bkg_err = float(parameters["reference_data"][sr]["bkg_err"]) elif "bkg_errp" in parameters["reference_data"][sr]: # Asymmetric error: as a rough approximation, use the mean of the squares self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_errp"])**2 + float(parameters["reference_data"][sr]["bkg_errm"])**2)/sqrt(2.) elif "bkg_err_sys" in parameters["reference_data"][sr]: # Total error = independent quadratic sum of statistical and systematical component self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + float(parameters["reference_data"][sr]["bkg_err_sys"])**2 ) elif "bkg_err_sysp" in parameters["reference_data"][sr]: self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2. + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2.)
def calc_likelihood(self): """ Calculates approximate likelihood using the root-find method """ analysis = self.resultCollector.analysis sr = self.resultCollector.sr parameters = Info.get_analysis_parameters(analysis) # Determine parameters sig = float(self.resultCollector.signal_normevents) sig_err = float(self.resultCollector.signal_err_tot) obs = float(parameters["reference_data"][sr]["obs"]) bkg = float(parameters["reference_data"][sr]["bkg"]) bkg_err = 0 if "bkg_err" in parameters["reference_data"][sr]: bkg_err = float(parameters["reference_data"][sr]["bkg_err"]) elif "bkg_errp" in parameters["reference_data"][sr]: # Asymmetric error: as a rough approximation, use the mean of the squares bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_errp"])**2 + float(parameters["reference_data"][sr]["bkg_errm"])**2)/sqrt(2.) elif "bkg_err_sys" in parameters["reference_data"][sr]: # Total error = independent quadratic sum of statistical and systematical component bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + float(parameters["reference_data"][sr]["bkg_err_sys"])**2 ) elif "bkg_err_sysp" in parameters["reference_data"][sr]: bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2. + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2.) self.likelihood = likelihood(1.0, obs, bkg, sig, bkg_err, sig_err, [0.0,0.0])
class Entry(Gtk.EventBox): __gtype_name__ = "CommanderEntry" def __init__(self, view): Gtk.EventBox.__init__(self) self._view = view self.set_visible_window(False) hbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 3) hbox.show() hbox.set_border_width(3) # context for the view self._entry = Gtk.Entry() self._entry.set_has_frame(False) self._entry.set_name("gedit-commander-entry") self._entry.show() css = Gtk.CssProvider() css.load_from_data( bytes( """ @binding-set terminal-like-bindings { unbind "<Control>A"; bind "<Control>W" { "delete-from-cursor" (word-ends, -1) }; bind "<Control>A" { "move-cursor" (buffer-ends, -1, 0) }; bind "<Control>U" { "delete-from-cursor" (display-line-ends, -1) }; bind "<Control>K" { "delete-from-cursor" (display-line-ends, 1) }; bind "<Control>E" { "move-cursor" (buffer-ends, 1, 0) }; bind "Escape" { "delete-from-cursor" (display-lines, 1) }; } GtkEntry#gedit-commander-entry { gtk-key-bindings: terminal-like-bindings; /* Override background to anything. This is weird, but doing this we can then in code use widget.override_background to set the color dynamically to the same color as the gedit view */ background: transparent; border-width: 0; box-shadow: 0 0 transparent; transition: none; } """, "utf-8", ) ) # FIXME: remove hardcopy of 600 (GTK_STYLE_PROVIDER_PRIORITY_APPLICATION) # https://bugzilla.gnome.org/show_bug.cgi?id=646860 self._entry.get_style_context().add_provider(css, 600) self._prompt_label = Gtk.Label(label="<b>>>></b>", use_markup=True) self._prompt_label.show() self._entry.connect("focus-out-event", self.on_entry_focus_out) self._entry.connect("key-press-event", self.on_entry_key_press) self._history = History(os.path.join(GLib.get_user_config_dir(), "gedit/commander/history")) self._prompt = None self._accel_group = None hbox.pack_start(self._prompt_label, False, False, 0) hbox.pack_start(self._entry, True, True, 0) self.copy_style_from_view() self.view_style_updated_id = self._view.connect("style-updated", self.on_view_style_updated) self.add(hbox) self.attach() self._entry.grab_focus() self._wait_timeout = 0 self._info_window = None self.connect("destroy", self.on_destroy) self.connect_after("size-allocate", self.on_size_allocate) self.view_draw_id = self._view.connect_after("draw", self.on_draw) self._history_prefix = None self._suspended = None self._handlers = [ [0, Gdk.KEY_Up, self.on_history_move, -1], [0, Gdk.KEY_Down, self.on_history_move, 1], [None, Gdk.KEY_Return, self.on_execute, None], [None, Gdk.KEY_KP_Enter, self.on_execute, None], [0, Gdk.KEY_Tab, self.on_complete, None], [0, Gdk.KEY_ISO_Left_Tab, self.on_complete, None], ] self._re_complete = re.compile("(\"((?:\\\\\"|[^\"])*)\"?|'((?:\\\\'|[^'])*)'?|[^\s]+)") self._command_state = commands.Commands.State() def on_view_style_updated(self, widget): self.copy_style_from_view() def get_border_color(self): color = self.get_background_color().copy() color.red = 1 - color.red color.green = 1 - color.green color.blue = 1 - color.blue color.alpha = 0.5 return color def get_background_color(self): context = self._view.get_style_context() return context.get_background_color(Gtk.StateFlags.NORMAL) def get_foreground_color(self): context = self._view.get_style_context() return context.get_color(Gtk.StateFlags.NORMAL) def get_font(self): context = self._view.get_style_context() return context.get_font(Gtk.StateFlags.NORMAL) def copy_style_from_view(self, widget=None): if widget != None: context = self._view.get_style_context() font = context.get_font(Gtk.StateFlags.NORMAL) widget.override_color(Gtk.StateFlags.NORMAL, self.get_foreground_color()) widget.override_font(self.get_font()) else: if self._entry: self.copy_style_from_view(self._entry) if self._prompt_label: self.copy_style_from_view(self._prompt_label) def view(self): return self._view def on_size_allocate(self, widget, alloc): alloc = self.get_allocation() self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, alloc.height) win = self._view.get_window(Gtk.TextWindowType.BOTTOM) self.set_size_request(win.get_width(), -1) # NOTE: we need to do this explicitly somehow, otherwise the window # size will not be updated unless something else happens, not exactly # sure what. This might be caused by the multi notebook, or custom # animation layouting? self._view.get_parent().resize_children() def attach(self): # Attach ourselves in the text view, and position just above the # text window win = self._view.get_window(Gtk.TextWindowType.TEXT) alloc = self.get_allocation() self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, max(alloc.height, 1)) self._view.add_child_in_window(self, Gtk.TextWindowType.BOTTOM, 0, 0) win = self._view.get_window(Gtk.TextWindowType.BOTTOM) self.show() self.set_size_request(win.get_width(), -1) def on_entry_focus_out(self, widget, evnt): if self._entry.get_sensitive(): self.destroy() def on_entry_key_press(self, widget, evnt): state = evnt.state & Gtk.accelerator_get_default_mod_mask() text = self._entry.get_text() if evnt.keyval == Gdk.KEY_Escape: if self._info_window: if self._suspended: self._suspended.resume() if self._info_window: self._info_window.destroy() self._entry.set_sensitive(True) elif self._accel_group: self._accel_group = self._accel_group.parent if not self._accel_group or not self._accel_group.parent: self._entry.set_editable(True) self._accel_group = None self.prompt() elif text: self._entry.set_text("") elif self._command_state: self._command_state.clear() self.prompt() else: self._view.grab_focus() self.destroy() return True if state or self._accel_group: # Check if it should be handled by the accel group group = self._accel_group if not self._accel_group: group = commands.Commands().accelerator_group() accel = group.activate(evnt.keyval, state) if isinstance(accel, commands.accel_group.AccelGroup): self._accel_group = accel self._entry.set_text("") self._entry.set_editable(False) self.prompt() return True elif isinstance(accel, commands.accel_group.AccelCallback): self._entry.set_editable(True) self.run_command(lambda: accel.activate(self._command_state, self)) return True if not self._entry.get_editable(): return True for handler in self._handlers: if ( (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state) ): return True if self._info_window and self._info_window.empty(): self._info_window.destroy() self._history_prefix = None return False def on_history_move(self, direction, modifier): pos = self._entry.get_position() self._history.update(self._entry.get_text()) if self._history_prefix == None: if len(self._entry.get_text()) == pos: self._history_prefix = self._entry.get_chars(0, pos) else: self._history_prefix = "" if self._history_prefix == None: hist = "" else: hist = self._history_prefix next = self._history.move(direction, hist) if next != None: self._entry.set_text(next) self._entry.set_position(-1) return True def prompt(self, pr=""): self._prompt = pr if self._accel_group != None: pr = "<i>%s</i>" % (saxutils.escape(self._accel_group.full_name()),) if not pr: pr = "" else: pr = " " + pr self._prompt_label.set_markup("<b>>>></b>%s" % pr) def make_info(self): if self._info_window == None: self._info_window = Info(self) self._info_window.show() self._info_window.connect("destroy", self.on_info_window_destroy) def on_info_window_destroy(self, widget): self._info_window = None def info_show(self, text="", use_markup=False): self.make_info() self._info_window.add_lines(text, use_markup) def info_status(self, text): self.make_info() self._info_window.status(text) def info_add_action(self, stock, callback, data=None): self.make_info() return self._info_window.add_action(stock, callback, data) def command_history_done(self): self._history.add(self._entry.get_text()) self._history_prefix = None self._entry.set_text("") def on_wait_cancel(self): if self._suspended: self._suspended.resume() if self._cancel_button: self._cancel_button.destroy() if self._info_window and self._info_window.empty(): self._info_window.destroy() self._entry.grab_focus() self._entry.set_sensitive(True) def _show_wait_cancel(self): self._cancel_button = self.info_add_action(Gtk.STOCK_STOP, self.on_wait_cancel) self.info_status("<i>Waiting to finish...</i>") self._wait_timeout = 0 return False def _complete_word_match(self, match): for i in (3, 2, 0): if match.group(i) != None: return [match.group(i), match.start(i), match.end(i)] def on_suspend_resume(self): if self._wait_timeout: GLib.source_remove(self._wait_timeout) self._wait_timeout = 0 else: self._cancel_button.destroy() self._cancel_button = None self.info_status(None) self._entry.set_sensitive(True) self.command_history_done() if self._entry.props.has_focus or (self._info_window and not self._info_window.empty()): self._entry.grab_focus() self.on_execute(None, 0) def ellipsize(self, s, size): if len(s) <= size: return s mid = (size - 4) / 2 return s[:mid] + "..." + s[-mid:] def destroy(self): self.hide() Gtk.EventBox.destroy(self) def run_command(self, cb): self._suspended = None try: ret = cb() except Exception as e: self.command_history_done() self._command_state.clear() self.prompt() # Show error in info self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True) if not isinstance(e, commands.exceptions.Execute): self.info_show(self.format_trace(), False) return None mod = sys.modules["commander.commands.result"] if ret == mod.Result.SUSPEND: # Wait for it... self._suspended = ret ret.register(self.on_suspend_resume) self._wait_timeout = GLib.timeout_add(500, self._show_wait_cancel) self._entry.set_sensitive(False) else: self.command_history_done() self.prompt("") if ret == mod.Result.PROMPT: self.prompt(ret.prompt) elif ( (ret == None or ret == mod.HIDE) and not self._prompt and (not self._info_window or self._info_window.empty()) ): self._command_state.clear() self._view.grab_focus() self.destroy() else: self._entry.grab_focus() return ret def format_trace(self): tp, val, tb = sys.exc_info() origtb = tb thisdir = os.path.dirname(__file__) # Skip frames up until after the last entry.py... while True: filename = tb.tb_frame.f_code.co_filename dname = os.path.dirname(filename) if not dname.startswith(thisdir): break tb = tb.tb_next msg = traceback.format_exception(tp, val, tb) r = "".join(msg[0:-1]) # This is done to prevent cyclic references, see python # documentation on sys.exc_info del origtb return r def on_execute(self, dummy, modifier): if self._info_window and not self._suspended: self._info_window.destroy() text = self._entry.get_text().strip() words = list(self._re_complete.finditer(text)) wordsstr = [] for word in words: spec = self._complete_word_match(word) wordsstr.append(spec[0]) if not wordsstr and not self._command_state: self._entry.set_text("") return self.run_command( lambda: commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier) ) return True def on_complete(self, dummy, modifier): # First split all the text in words text = self._entry.get_text() pos = self._entry.get_position() words = list(self._re_complete.finditer(text)) wordsstr = [] for word in words: spec = self._complete_word_match(word) wordsstr.append(spec[0]) # Find out at which word the cursor actually is # Examples: # * hello world| # * hello| world # * |hello world # * hello wor|ld # * hello | world # * "hello world|" posidx = None for idx in range(0, len(words)): spec = self._complete_word_match(words[idx]) if words[idx].start(0) > pos: # Empty space, new completion wordsstr.insert(idx, "") words.insert(idx, None) posidx = idx break elif spec[2] == pos: # At end of word, resume completion posidx = idx break elif spec[1] <= pos and spec[2] > pos: # In middle of word, do not complete return True if posidx == None: wordsstr.append("") words.append(None) posidx = len(wordsstr) - 1 # First word completes a command, if not in any special 'mode' # otherwise, relay completion to the command, or complete by advice # from the 'mode' (prompt) cmds = commands.Commands() if not self._command_state and posidx == 0: # Complete the first command ret = commands.completion.command(words=wordsstr, idx=posidx) else: complete = None realidx = posidx if not self._command_state: # Get the command first cmd = commands.completion.single_command(wordsstr, 0) realidx -= 1 ww = wordsstr[1:] else: cmd = self._command_state.top() ww = wordsstr if cmd: complete = cmd.autocomplete_func() if not complete: return True # 'complete' contains a dict with arg -> func to do the completion # of the named argument the command (or stack item) expects args, varargs = cmd.args() # Remove system arguments s = ["argstr", "args", "entry", "view"] args = list(filter(lambda x: not x in s, args)) if realidx < len(args): arg = args[realidx] elif varargs: arg = "*" else: return True if not arg in complete: return True func = complete[arg] try: spec = utils.getargspec(func) if not ww: ww = [""] kwargs = {"words": ww, "idx": realidx, "view": self._view} if not spec.keywords: for k in list(kwargs.keys()): if not k in spec.args: del kwargs[k] ret = func(**kwargs) except Exception as e: # Can be number of arguments, or return values or simply buggy # modules print(e) traceback.print_exc() return True if not ret or not ret[0]: return True res = ret[0] completed = ret[1] if len(ret) > 2: after = ret[2] else: after = " " # Replace the word if words[posidx] == None: # At end of everything, just append spec = None self._entry.insert_text(completed, self._entry.get_text_length()) self._entry.set_position(-1) else: spec = self._complete_word_match(words[posidx]) self._entry.delete_text(spec[1], spec[2]) self._entry.insert_text(completed, spec[1]) self._entry.set_position(spec[1] + len(completed)) if len(res) == 1: # Full completion lastpos = self._entry.get_position() if not isinstance(res[0], commands.module.Module) or not res[0].commands(): if ( words[posidx] and after == " " and (words[posidx].group(2) != None or words[posidx].group(3) != None) ): lastpos = lastpos + 1 self._entry.insert_text(after, lastpos) self._entry.set_position(lastpos + 1) elif completed == wordsstr[posidx] or not res[0].method: self._entry.insert_text(".", lastpos) self._entry.set_position(lastpos + 1) if self._info_window: self._info_window.destroy() else: # Show popup with completed items if self._info_window: self._info_window.clear() ret = [] for x in res: if isinstance(x, commands.method.Method): ret.append("<b>" + saxutils.escape(x.name) + "</b> (<i>" + x.oneline_doc() + "</i>)") else: ret.append(str(x)) self.info_show("\n".join(ret), True) return True def on_draw(self, widget, ct): win = widget.get_window(Gtk.TextWindowType.BOTTOM) if not Gtk.cairo_should_draw_window(ct, win): return False Gtk.cairo_transform_to_window(ct, widget, win) color = self.get_border_color() width = win.get_width() ct.set_source_rgba(color.red, color.green, color.blue, color.alpha) ct.move_to(0, 0) ct.line_to(width, 0) ct.stroke() return False def on_destroy(self, widget): self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, 0) self._view.disconnect(self.view_style_updated_id) self._view.disconnect(self.view_draw_id) if self._info_window: self._info_window.destroy() self._history.save()
def __init__(self): self.lcd.clear() self.lcd.backlight(self.lcd.YELLOW) self.info = Info()
class Display: lcd = Adafruit_CharLCDPlate() info = None screen = [] screenIdx = 0 systemHalt = False def __init__(self): self.lcd.clear() self.lcd.backlight(self.lcd.YELLOW) self.info = Info() def show(self): if self.screenIdx == 0: self.screen = self.info.screen0 elif self.screenIdx == 1: self.screen = self.info.screen1 elif self.screenIdx == 2: self.screen = self.info.screen2 elif self.screenIdx == 3: self.screen = self.info.screen3 elif self.screenIdx == 4: self.screen = self.info.screen4 elif self.screenIdx == 5: self.screen = self.info.screen5 s = self.screen[0] + "\n" + self.screen[1] self.lcd.clear() self.lcd.message(s) def update(self): if self.systemHalt: return lock = self.info.isLocked() # appropriately set backlight if lock: self.setBackgroundGreen() self.info.fillData() else: self.setBackgroundRed() self.info.noData() self.show() # if not self.systemHalt: self.show() def moveUp(self): if self.screenIdx == 0: self.screenIdx = self.info.numPages else: self.screenIdx -= 1 def moveDown(self): if self.screenIdx == self.info.numPages: self.screenIdx = 0 else: self.screenIdx += 1 def action(self): if self.screenIdx == 0: self.action0() elif self.screenIdx == 1: self.action1() elif self.screenIdx == 2: self.action2() elif self.screenIdx == 3: self.action3() elif self.screenIdx == 4: self.action4() elif self.screenIdx == 5: self.action5() def action0(self): """ action for page 1 """ pass def action1(self): """ action for page 2 """ pass def action2(self): """ action for page 3 """ pass def action3(self): """ reboot """ self.systemHalt = True self.setBackgroundOff() self.lcd.clear() self.lcd.message("Rebooting ...") subprocess.call("sync") subprocess.call("reboot") # exit(0) def action4(self): """ shutdown """ self.systemHalt = True self.setBackgroundOff() self.lcd.clear() self.lcd.message("Wait till screen\nis off + 15secs!") subprocess.call("sync") subprocess.call(["shutdown", "-h", "now"]) # exit(0) def action5(self): self.exit() def exit(self): self.setLcdOff() exit(0) def setBackgroundGreen(self): self.lcd.backlight(self.lcd.GREEN) def setBackgroundOff(self): self.lcd.backlight(self.lcd.TEAL) def setBackgroundRed(self): self.lcd.backlight(self.lcd.RED) def setLcdOff(self): self.lcd.clear() self.lcd.backlight(self.lcd.OFF) def setLcdOn(self): self.lcd.clear() self.lcd.backlight(self.lcd.ON)
class Entry(Gtk.Box): __gtype_name__ = "CommanderEntry" def _show(self): self._reveal.set_reveal_child(True) def _hide(self): self._reveal.set_reveal_child(False) def __init__(self, view): super(Entry, self).__init__() self._view = view view.connect("destroy", self._on_view_destroyed) self._history = History(os.path.join(GLib.get_user_config_dir(), 'gedit/commander/history')) self._history_prefix = None self._prompt_text = None self._accel_group = None self._wait_timeout = 0 self._cancel_button = None self._info = None self._info_revealer = None self._suspended = None self._handlers = [ [0, Gdk.KEY_Up, self._on_history_move, -1], [0, Gdk.KEY_Down, self._on_history_move, 1], [None, Gdk.KEY_Return, self._on_execute, None], [None, Gdk.KEY_KP_Enter, self._on_execute, None], [0, Gdk.KEY_Tab, self._on_complete, None], [0, Gdk.KEY_ISO_Left_Tab, self._on_complete, None] ] self._re_complete = re.compile('("((?:\\\\"|[^"])*)"?|\'((?:\\\\\'|[^\'])*)\'?|[^\s]+)') self._command_state = commands.Commands.State() self.connect('destroy', self._on_destroy) self._build_ui() self._setup_keybindings() self._attach() def view(self): return self._view def _setup_keybindings(self): css = Gtk.CssProvider() css.load_from_data(bytes(""" @binding-set terminal-like-bindings { unbind "<Control>A"; bind "<Control>W" { "delete-from-cursor" (word-ends, -1) }; bind "<Control>A" { "move-cursor" (buffer-ends, -1, 0) }; bind "<Control>U" { "delete-from-cursor" (display-line-ends, -1) }; bind "<Control>K" { "delete-from-cursor" (display-line-ends, 1) }; bind "<Control>E" { "move-cursor" (buffer-ends, 1, 0) }; bind "Escape" { "delete-from-cursor" (display-lines, 1) }; } GtkEntry#gedit-commander-entry { gtk-key-bindings: terminal-like-bindings; background-image: none; box-shadow: 0 0; transition: none; border: 0; } """, 'utf-8')) self._entry.get_style_context().add_provider(css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) def _find_overlay(self, view): parent = view.get_parent() while not isinstance(parent, Gtk.Overlay): parent = parent.get_parent() return parent def _build_ui(self): self.set_orientation(Gtk.Orientation.VERTICAL) self._overlay = self._find_overlay(self._view) hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6) hbox.show() self.pack_end(hbox, False, False, 0) self._info_revealer = Gtk.Revealer() self._info_revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP) self._info_revealer.set_transition_duration(150) self.pack_start(self._info_revealer, False, False, 0) self._info_revealer.connect('notify::child-revealed', self._on_info_revealer_child_revealed) self._prompt_label = Gtk.Label(label='<b>>>></b>', use_markup=True) self._prompt_label.set_margin_top(3) self._prompt_label.set_margin_bottom(3) self._prompt_label.set_margin_start(3) self._prompt_label.show() hbox.add(self._prompt_label) self._entry = Gtk.Entry() self._entry.set_has_frame(False) self._entry.set_name('gedit-commander-entry') self._entry.set_hexpand(True) self._entry.set_margin_top(3) self._entry.set_margin_bottom(3) self._entry.set_margin_end(3) self._entry.connect('key-press-event', self._on_entry_key_press) self._entry.show() hbox.add(self._entry) self._copy_style_from_view() self._view_style_updated_id = self._view.connect('style-updated', self._on_view_style_updated) def _on_view_destroyed (self, widget, user_data=None): self._view.disconnect(self._view_style_updated_id) self._view_style_updated_id = None def _on_view_style_updated(self, widget): self._copy_style_from_view() @property def _border_color(self): style = self._view.get_buffer().get_style_scheme().get_style('right-margin') if not style is None and style.props.foreground_set: color = Gdk.RGBA() color.parse(style.props.foreground) else: color = self._get_background_color(Gtk.StateFlags.NORMAL, 'bottom').copy() color.red = 1 - color.red color.green = 1 - color.green color.blue = 1 - color.blue color.alpha = 0.3 return color def _get_background_color(self, state, cls=None): context = self._view.get_style_context() context.save() if not cls is None: context.add_class(cls) ret = context.get_background_color(state) context.restore() return ret def _get_foreground_color(self, state, cls=None): context = self._view.get_style_context() context.save() if not cls is None: context.add_class(cls) ret = context.get_color(state) context.restore() return ret def _get_font(self): context = self._view.get_style_context() return context.get_font(Gtk.StateFlags.NORMAL) def _styled_widgets(self): widgets = [self, self._entry, self._prompt_label] if not self._info is None: widgets.append(self._info) widgets.append(self._info.text_view) return widgets def _modify_bg(self, col, widget): if self._info is None or (self._info.text_view != widget and self._info != widget): return col d = 0.1 h, l, s = colorsys.rgb_to_hls(col.red, col.green, col.blue) if l < 0.5: factor = 1 + d else: factor = 1 - d l = max(0, min(1, l * factor)) s = max(0, min(1, s * factor)) r, g, b = colorsys.hls_to_rgb(h, l, s) return Gdk.RGBA(r, g, b, col.alpha) def _copy_style_from_view(self, widgets=None): font = self._get_font() fg = self._get_foreground_color(Gtk.StateFlags.NORMAL, 'bottom') bg = self._get_background_color(Gtk.StateFlags.NORMAL, 'bottom') fgsel = self._get_foreground_color(Gtk.StateFlags.SELECTED) bgsel = self._get_background_color(Gtk.StateFlags.SELECTED) cursor = self._view.style_get_property('cursor-color') if not cursor is None: cursor = Gdk.RGBA.from_color(cursor) secondary_cursor = self._view.style_get_property('secondary-cursor-color') if not secondary_cursor is None: secondary_cursor = Gdk.RGBA.from_color(secondary_cursor) if widgets is None: widgets = self._styled_widgets() for widget in widgets: widget.override_color(Gtk.StateFlags.NORMAL, fg) widget.override_background_color(Gtk.StateFlags.NORMAL, self._modify_bg(bg, widget)) widget.override_color(Gtk.StateFlags.SELECTED, fgsel) widget.override_background_color(Gtk.StateFlags.SELECTED, self._modify_bg(bgsel, widget)) widget.override_font(font) widget.override_cursor(cursor, secondary_cursor) def _attach(self): reveal = Gtk.Revealer() reveal.add(self) self.show() reveal.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP) reveal.set_transition_duration(200) reveal.set_valign(Gtk.Align.END) reveal.set_halign(Gtk.Align.FILL) self._overlay.add_overlay(reveal) reveal.show() reveal.set_reveal_child(True) self._reveal = reveal self._entry.grab_focus() def grab_focus(self): self._entry.grab_focus() def _on_entry_key_press(self, widget, evnt): state = evnt.state & Gtk.accelerator_get_default_mod_mask() text = self._entry.get_text() if evnt.keyval == Gdk.KEY_Escape: if not self._info is None: if not self._suspended is None: self._suspended.resume() if not self._info is None: self._info_revealer.set_reveal_child(False) self._entry.set_sensitive(True) elif self._accel_group: self._accel_group = self._accel_group.parent if not self._accel_group or not self._accel_group.parent: self._entry.set_editable(True) self._accel_group = None self._prompt() elif text: self._entry.set_text('') elif self._command_state: self._command_state.clear() self._prompt() else: self._view.grab_focus() self._reveal.set_reveal_child(False) return True if state or self._accel_group: # Check if it should be handled by the accel group group = self._accel_group if not self._accel_group: group = commands.Commands().accelerator_group() accel = group.activate(evnt.keyval, state) if isinstance(accel, commands.accel_group.AccelGroup): self._accel_group = accel self._entry.set_text('') self._entry.set_editable(False) self._prompt() return True elif isinstance(accel, commands.accel_group.AccelCallback): self._entry.set_editable(True) self._run_command(lambda: accel.activate(self._command_state, self)) return True if not self._entry.get_editable(): return True for handler in self._handlers: if (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state): return True if not self._info is None and self._info.is_empty: self._info_revealer.set_reveal_child(False) self._history_prefix = None return False def _on_history_move(self, direction, modifier): pos = self._entry.get_position() self._history.update(self._entry.get_text()) if self._history_prefix == None: if len(self._entry.get_text()) == pos: self._history_prefix = self._entry.get_chars(0, pos) else: self._history_prefix = '' if self._history_prefix == None: hist = '' else: hist = self._history_prefix next = self._history.move(direction, hist) if next != None: self._entry.set_text(next) self._entry.set_position(-1) return True def _prompt(self, pr=''): self._prompt_text = pr if self._accel_group != None: pr = '<i>%s</i>' % (saxutils.escape(self._accel_group.full_name()),) if not pr: pr = '' else: pr = ' ' + pr self._prompt_label.set_markup('<b>>>></b>%s' % pr) def _make_info(self): if self._info is None: self._info = Info() self._copy_style_from_view([self._info, self._info.text_view]) self._info_revealer.add(self._info) self._info.show() self._info_revealer.show() self._info_revealer.set_reveal_child(True) self._info.connect('destroy', self._on_info_destroy) def _on_info_revealer_child_revealed(self, widget, pspec): if not self._info_revealer.get_child_revealed(): self._info.destroy() self._info_revealer.hide() def _on_info_destroy(self, widget): self._info = None def info_show(self, text='', use_markup=False): self._make_info() self._info.add_lines(text, use_markup) def info_status(self, text): self._make_info() self._info.status(text) def _info_add_action(self, stock, callback, data=None): self._make_info() return self._info.add_action(stock, callback, data) def _command_history_done(self): self._history.add(self._entry.get_text()) self._history_prefix = None self._entry.set_text('') def _on_wait_cancel(self): self._on_execute(None, 0) def _show_wait_cancel(self): self._cancel_button = self._info_add_action('process-stop-symbolic', self._on_wait_cancel) self.info_status('<i>Waiting to finish\u2026</i>') self._wait_timeout = 0 return False def _complete_word_match(self, match): for i in (3, 2, 0): if match.group(i) != None: return [match.group(i), match.start(i), match.end(i)] def _on_suspend_resume(self): if self._wait_timeout: GLib.source_remove(self._wait_timeout) self._wait_timeout = 0 else: if not self._cancel_button is None: self._cancel_button.destroy() self._cancel_button = None self.info_status(None) self._entry.set_sensitive(True) self._command_history_done() if self._entry.props.has_focus or (not self._info is None and not self._info.is_empty): self._entry.grab_focus() def _run_command(self, cb): self._suspended = None try: ret = cb() except Exception as e: sys.stderr.write(self._format_trace() + '\n') self._command_history_done() self._command_state.clear() self._prompt() # Show error in info self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True) if not isinstance(e, commands.exceptions.Execute): self.info_show(self._format_trace(), False) return None mod = sys.modules['commander.commands.result'] if ret == mod.Result.SUSPEND: # Wait for it... self._suspended = ret ret.register(self._on_suspend_resume) self._wait_timeout = GLib.timeout_add(500, self._show_wait_cancel) self._entry.set_sensitive(False) else: self._command_history_done() self._prompt('') if ret == mod.Result.PROMPT: self._prompt(ret.prompt) elif (ret == None or ret == mod.HIDE) and not self._prompt_text and (self._info is None or self._info.is_empty): self._command_state.clear() self._view.grab_focus() self._reveal.set_reveal_child(False) else: self._entry.grab_focus() return ret def _format_trace(self): tp, val, tb = sys.exc_info() origtb = tb thisdir = os.path.dirname(__file__) # Skip frames up until after the last entry.py... while not tb is None: filename = tb.tb_frame.f_code.co_filename dname = os.path.dirname(filename) if not dname.startswith(thisdir): break tb = tb.tb_next msg = traceback.format_exception(tp, val, tb) r = ''.join(msg[0:-1]) # This is done to prevent cyclic references, see python # documentation on sys.exc_info del origtb return r def _on_execute(self, dummy, modifier): if not self._info is None and not self._suspended: self._info_revealer.set_reveal_child(False) text = self._entry.get_text().strip() words = list(self._re_complete.finditer(text)) wordsstr = [] for word in words: spec = self._complete_word_match(word) wordsstr.append(spec[0]) if not wordsstr and not self._command_state: self._entry.set_text('') return self._run_command(lambda: commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier)) return True def _on_complete(self, dummy, modifier): # First split all the text in words text = self._entry.get_text() pos = self._entry.get_position() words = list(self._re_complete.finditer(text)) wordsstr = [] for word in words: spec = self._complete_word_match(word) wordsstr.append(spec[0]) # Find out at which word the cursor actually is # Examples: # * hello world| # * hello| world # * |hello world # * hello wor|ld # * hello | world # * "hello world|" posidx = None for idx in range(0, len(words)): spec = self._complete_word_match(words[idx]) if words[idx].start(0) > pos: # Empty space, new completion wordsstr.insert(idx, '') words.insert(idx, None) posidx = idx break elif spec[2] == pos: # At end of word, resume completion posidx = idx break elif spec[1] <= pos and spec[2] > pos: # In middle of word, do not complete return True if posidx == None: wordsstr.append('') words.append(None) posidx = len(wordsstr) - 1 # First word completes a command, if not in any special 'mode' # otherwise, relay completion to the command, or complete by advice # from the 'mode' (prompt) cmds = commands.Commands() if not self._command_state and posidx == 0: # Complete the first command ret = commands.completion.command(words=wordsstr, idx=posidx) else: complete = None realidx = posidx if not self._command_state: # Get the command first cmd = commands.completion.single_command(wordsstr, 0) realidx -= 1 ww = wordsstr[1:] else: cmd = self._command_state.top() ww = wordsstr if cmd: complete = cmd.autocomplete_func() if not complete: return True # 'complete' contains a dict with arg -> func to do the completion # of the named argument the command (or stack item) expects args, varargs = cmd.args() # Remove system arguments s = ['argstr', 'args', 'entry', 'view'] args = list(filter(lambda x: not x in s, args)) if realidx < len(args): arg = args[realidx] elif varargs: arg = '*' else: return True if not arg in complete: return True func = complete[arg] try: spec = utils.getargspec(func) if not ww: ww = [''] kwargs = { 'words': ww, 'idx': realidx, 'view': self._view } if not spec.keywords: for k in list(kwargs.keys()): if not k in spec.args: del kwargs[k] ret = func(**kwargs) except Exception as e: # Can be number of arguments, or return values or simply buggy # modules print(e) traceback.print_exc() return True if not ret or not ret[0]: return True res = ret[0] completed = ret[1] if len(ret) > 2: after = ret[2] else: after = ' ' # Replace the word if words[posidx] == None: # At end of everything, just append spec = None self._entry.insert_text(completed, self._entry.get_text_length()) self._entry.set_position(-1) else: spec = self._complete_word_match(words[posidx]) self._entry.delete_text(spec[1], spec[2]) self._entry.insert_text(completed, spec[1]) self._entry.set_position(spec[1] + len(completed)) if len(res) == 1: # Full completion lastpos = self._entry.get_position() if not isinstance(res[0], commands.module.Module) or not res[0].commands(): if words[posidx] and after == ' ' and (words[posidx].group(2) != None or words[posidx].group(3) != None): lastpos = lastpos + 1 self._entry.insert_text(after, lastpos) self._entry.set_position(lastpos + 1) elif completed == wordsstr[posidx] or not res[0].method: self._entry.insert_text('.', lastpos) self._entry.set_position(lastpos + 1) if not self._info is None: self._info_revealer.set_reveal_child(False) else: # Show popup with completed items if not self._info is None: self._info.clear() ret = [] for x in res: if isinstance(x, commands.method.Method): ret.append('<b>' + saxutils.escape(x.name) + '</b> (<i>' + x.oneline_doc() + '</i>)') else: ret.append(str(x)) self.info_show("\n".join(ret), True) return True def do_draw(self, ctx): ret = Gtk.Box.do_draw(self, ctx) col = self._border_color ctx.set_line_width(1) ctx.set_source_rgba(col.red, col.green, col.blue, col.alpha) w = self.get_allocated_width() ctx.move_to(0, 0.5) ctx.line_to(w, 0.5) ctx.stroke() if not self._info is None: alloc = self._info_revealer.get_allocation() y = alloc.y + alloc.height + 0.5 if y >= 3: ctx.move_to(0, y) ctx.line_to(w, y) ctx.stroke() return ret def _on_destroy(self, widget): # Note we do this not as an override because somehow something # goes wrong when finalizing in that case, maybe self is NULL # or something like that, and then gets some new empty instance? if self._view_style_updated_id: self._view.disconnect(self._view_style_updated_id) self._history.save() self._view = None self._view_style_updated_id = None
def make_info(self): if self._info_window == None: self._info_window = Info(self) self._info_window.show() self._info_window.connect('destroy', self.on_info_window_destroy)
class Entry(gtk.EventBox): def __init__(self, view): gtk.EventBox.__init__(self) self._view = view hbox = gtk.HBox(False, 3) hbox.show() hbox.set_border_width(3) self._entry = gtk.Entry() self._entry.modify_font(self._view.style.font_desc) self._entry.set_has_frame(False) self._entry.set_name('command-bar') self._entry.modify_text(gtk.STATE_NORMAL, self._view.style.text[gtk.STATE_NORMAL]) self._entry.set_app_paintable(True) self._entry.connect('realize', self.on_realize) self._entry.connect('expose-event', self.on_entry_expose) self._entry.show() self._prompt_label = gtk.Label('<b>>>></b>') self._prompt_label.set_use_markup(True) self._prompt_label.modify_font(self._view.style.font_desc) self._prompt_label.show() self._prompt_label.modify_fg(gtk.STATE_NORMAL, self._view.style.text[gtk.STATE_NORMAL]) self.modify_bg(gtk.STATE_NORMAL, self.background_gdk()) self._entry.modify_base(gtk.STATE_NORMAL, self.background_gdk()) self._entry.connect('focus-out-event', self.on_entry_focus_out) self._entry.connect('key-press-event', self.on_entry_key_press) self.connect_after('size-allocate', self.on_size_allocate) self.connect_after('expose-event', self.on_expose) self.connect_after('realize', self.on_realize) self._history = History(os.path.expanduser('~/.gnome2/gedit/commander/history')) self._prompt = None hbox.pack_start(self._prompt_label, False, False, 0) hbox.pack_start(self._entry, True, True, 0) self.add(hbox) self.attach() self._entry.grab_focus() self._wait_timeout = 0 self._info_window = None self.connect('destroy', self.on_destroy) self._history_prefix = None self._suspended = None self._handlers = [ [0, gtk.keysyms.Up, self.on_history_move, -1], [0, gtk.keysyms.Down, self.on_history_move, 1], [None, gtk.keysyms.Return, self.on_execute, None], [None, gtk.keysyms.KP_Enter, self.on_execute, None], [0, gtk.keysyms.Tab, self.on_complete, None], [0, gtk.keysyms.ISO_Left_Tab, self.on_complete, None] ] self._re_complete = re.compile('("((?:\\\\"|[^"])*)"?|\'((?:\\\\\'|[^\'])*)\'?|[^\s]+)') self._command_state = commands.Commands.State() def view(self): return self._view def on_realize(self, widget): widget.window.set_back_pixmap(None, False) def on_entry_expose(self, widget, evnt): ct = evnt.window.cairo_create() ct.rectangle(evnt.area.x, evnt.area.y, evnt.area.width, evnt.area.height) bg = self.background_color() ct.set_source_rgb(bg[0], bg[1], bg[1]) ct.fill() return False def on_expose(self, widget, evnt): ct = evnt.window.cairo_create() color = self.background_color() ct.rectangle(evnt.area.x, evnt.area.y, evnt.area.width, evnt.area.height) ct.clip() # Draw separator line ct.move_to(0, 0) ct.set_line_width(1) ct.line_to(self.allocation.width, 0) ct.set_source_rgb(1 - color[0], 1 - color[1], 1 - color[2]) ct.stroke() return False def on_size_allocate(self, widget, alloc): vwwnd = self._view.get_window(gtk.TEXT_WINDOW_BOTTOM).get_parent() size = vwwnd.get_size() position = vwwnd.get_position() self._view.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, alloc.height) def attach(self): # Attach ourselves in the text view, and position just above the # text window self._view.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 1) alloc = self._view.allocation self.show() self._view.add_child_in_window(self, gtk.TEXT_WINDOW_BOTTOM, 0, 0) self.set_size_request(alloc.width, -1) def background_gdk(self): bg = self.background_color() bg = map(lambda x: int(x * 65535), bg) return gtk.gdk.Color(bg[0], bg[1], bg[2]) def background_color(self): bg = self._view.get_style().base[self._view.state] return [bg.red / 65535.0 * 1.1, bg.green / 65535.0 * 1.1, bg.blue / 65535.0 * 0.9, 0.8] def on_entry_focus_out(self, widget, evnt): if self._entry.flags() & gtk.SENSITIVE: self.destroy() def on_entry_key_press(self, widget, evnt): state = evnt.state & gtk.accelerator_get_default_mod_mask() text = self._entry.get_text() if evnt.keyval == gtk.keysyms.Escape and self._info_window: if self._suspended: self._suspended.resume() if self._info_window: self._info_window.destroy() self._entry.set_sensitive(True) return True if evnt.keyval == gtk.keysyms.Escape: if text: self._entry.set_text('') elif self._command_state: self._command_state.clear() self.prompt() else: self._view.grab_focus() self.destroy() return True for handler in self._handlers: if (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state): return True if self._info_window and self._info_window.empty(): self._info_window.destroy() self._history_prefix = None return False def on_history_move(self, direction, modifier): pos = self._entry.get_position() self._history.update(self._entry.get_text()) if self._history_prefix == None: if len(self._entry.get_text()) == pos: self._history_prefix = self._entry.get_chars(0, pos) else: self._history_prefix = '' if self._history_prefix == None: hist = '' else: hist = self._history_prefix next = self._history.move(direction, hist) if next != None: self._entry.set_text(next) self._entry.set_position(-1) return True def prompt(self, pr=''): self._prompt = pr if not pr: pr = '' else: pr = ' ' + pr self._prompt_label.set_markup('<b>>>></b>%s' % pr) def make_info(self): if self._info_window == None: self._info_window = Info(self) self._info_window.show() self._info_window.connect('destroy', self.on_info_window_destroy) def on_info_window_destroy(self, widget): self._info_window = None def info_show(self, text='', use_markup=False): self.make_info() self._info_window.add_lines(text, use_markup) def info_status(self, text): self.make_info() self._info_window.status(text) def info_add_action(self, stock, callback, data=None): self.make_info() return self._info_window.add_action(stock, callback, data) def command_history_done(self): self._history.update(self._entry.get_text()) self._history.add() self._history_prefix = None self._entry.set_text('') def on_wait_cancel(self): if self._suspended: self._suspended.resume() if self._cancel_button: self._cancel_button.destroy() if self._info_window and self._info_window.empty(): self._info_window.destroy() self._entry.grab_focus() self._entry.set_sensitive(True) def _show_wait_cancel(self): self._cancel_button = self.info_add_action(gtk.STOCK_STOP, self.on_wait_cancel) self.info_status('<i>Waiting to finish...</i>') self._wait_timeout = 0 return False def _complete_word_match(self, match): for i in (3, 2, 0): if match.group(i) != None: return [match.group(i), match.start(i), match.end(i)] def on_suspend_resume(self): if self._wait_timeout: glib.source_remove(self._wait_timeout) self._wait_timeout = 0 else: self._cancel_button.destroy() self._cancel_button = None self.info_status(None) self._entry.set_sensitive(True) self.command_history_done() if self._entry.props.has_focus or (self._info_window and not self._info_window.empty()): self._entry.grab_focus() self.on_execute(None, 0) def ellipsize(self, s, size): if len(s) <= size: return s mid = (size - 4) / 2 return s[:mid] + '...' + s[-mid:] def destroy(self): self.hide() gtk.EventBox.destroy(self) def on_execute(self, dummy, modifier): if self._info_window and not self._suspended: self._info_window.destroy() text = self._entry.get_text().strip() words = list(self._re_complete.finditer(text)) wordsstr = [] for word in words: spec = self._complete_word_match(word) wordsstr.append(spec[0]) if not wordsstr and not self._command_state: self._entry.set_text('') return self._suspended = None try: ret = commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier) except Exception, e: self.command_history_done() self._command_state.clear() self.prompt() # Show error in info self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True) if not isinstance(e, commands.exceptions.Execute): self.info_show(traceback.format_exc(), False) return True if ret == commands.result.Result.SUSPEND: # Wait for it... self._suspended = ret ret.register(self.on_suspend_resume) self._wait_timeout = glib.timeout_add(500, self._show_wait_cancel) self._entry.set_sensitive(False) else: self.command_history_done() self.prompt('') if ret == commands.result.Result.PROMPT: self.prompt(ret.prompt) elif (ret == None or ret == commands.result.HIDE) and not self._prompt and (not self._info_window or self._info_window.empty()): self._command_state.clear() self._view.grab_focus() self.destroy() else: self._entry.grab_focus() return True
def info_clicked(self): info_window = Info() info_window.exec_()
searching = False #------------------------------------------------------------------------------- # INITIALISE GAME #------------------------------------------------------------------------------- pygame.mixer.pre_init(44100, -16, 16, 2048) pygame.init() pygame.display.set_icon(pygame.image.load(os.path.join("centipede", "icon.png"))) window = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT + DISPLAY_PANEL)) pygame.display.set_caption("Centipede (1.0.1)") pygame.mouse.set_visible(False) gameOver = Info(130, 280, pygame.image.load(os.path.join("centipede", "backtowork.png"))) # font for the display panel fontSmaller = pygame.font.SysFont('arial black', 20, False, False) gameTimer = pygame.time.Clock() gamePaused = False gamePlaying = False gameOverDisplayTimer = 0 HIGH_SCORE = 0 try: hiScoreFile = open('hiscore', 'r') HIGH_SCORE = int(hiScoreFile.readline())
def __init__(self, preferences, market): QMainWindow.__init__(self) self.preferences = preferences self.market = market # set up main window self.ui = Ui_MainWindow() self.ui.setupUi(self) # improve ui on mac if utilities.platform_is_mac(): self.adjust_for_mac() # connect market signals to our logic self.market.signal_log.connect(self.slot_log) self.market.signal_wallet.connect(self.display_wallet) self.market.signal_orderlag.connect(self.display_orderlag) self.market.signal_userorder.connect(self.display_userorder) self.market.signal_ticker.connect(self.update_ticker) # connect ui signals to our logic self.ui.pushButtonGo.released.connect(self.execute_trade) self.ui.tableAsk.clicked.connect(self.slot_update_price_from_asks) self.ui.tableBid.clicked.connect(self.slot_update_price_from_bids) self.ui.pushButtonCancel.released.connect(self.cancel_order) self.ui.textBrowserStatus.anchorClicked.connect(self.order_selected) self.ui.pushButtonSize.released.connect(self.recalculate_size) self.ui.pushButtonPrice.released.connect(self.update_price_best) self.ui.pushButtonTotal.released.connect(self.recalculate_total) self.ui.actionPreferences_2.triggered.connect(self.show_preferences) # associate log channels with their check boxes self.logchannels = [ [self.ui.checkBoxLogTicker, "tick"], [self.ui.checkBoxLogTrade, "TRADE"], [self.ui.checkBoxLogDepth, "depth"], ] # set correct resizing for the bid and ask tables self.ui.tableAsk.horizontalHeader().setResizeMode(QHeaderView.Stretch) self.ui.tableBid.horizontalHeader().setResizeMode(QHeaderView.Stretch) # set up info table self.info = Info(self, self.preferences, self.ui.tableInfo.clicked) self.ui.tableInfo.setModel(self.info) self.ui.tableInfo.horizontalHeader().setResizeMode(QHeaderView.Stretch) # connect to signals from info table self.info.signal_base_balance_clicked.connect(self.set_trade_size_from_wallet) self.info.signal_quote_balance_clicked.connect(self.set_trade_total_from_wallet) # initializes dynamic ui elements self.init() # activate market self.market.start() # show main window self.adjustSize() self.show() self.raise_()
def __init__(self, parent, title): wx.Frame.__init__(self, parent, title=title) # Splitters and Panels self.controls_map_splitter = wx.SplitterWindow(self) self.controls_map_splitter.SetMinimumPaneSize(300) controls_panel = wx.Panel(self.controls_map_splitter) map_panel = wx.Panel(self.controls_map_splitter) self.graphs_messages_splitter = wx.SplitterWindow(controls_panel) self.graphs_messages_splitter.SetMinimumPaneSize(50) graphs_panel = wx.Panel(self.graphs_messages_splitter) messages_panel = wx.Panel(self.graphs_messages_splitter) # World graphic self._graphics = worldmap.WorldMap(map_panel) self.graphics_sizer = wx.BoxSizer(wx.VERTICAL) self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND) map_panel.SetSizerAndFit(self.graphics_sizer) # Controls panel self.controls = Controls(controls_panel, (300, 250), self) # Info panel self.info = Info(controls_panel, (300, 250)) # Graph canvas self.graphs = graphs.Graphs(graphs_panel, (300, 300)) # Messages panel self.messages = Messages(messages_panel, (600, 200)) self.interface_sizer = wx.BoxSizer(wx.VERTICAL) self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL) self.controls_info_sizer.Add(self.info, 0, wx.EXPAND) self.controls_info_sizer.Add((20, -1), proportion=0) # Padding self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND) self.messages_sizer = wx.BoxSizer(wx.VERTICAL) self.messages_sizer.Add(self.messages, 1, wx.EXPAND) messages_panel.SetSizerAndFit(self.messages_sizer) self.graphs_sizer = wx.BoxSizer(wx.VERTICAL) self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND) graphs_panel.SetSizerAndFit(self.graphs_sizer) self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND) self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND) controls_panel.SetSizerAndFit(self.interface_sizer) self.graphs_messages_splitter.SplitHorizontally( messages_panel, graphs_panel ) self.controls_map_splitter.SplitVertically(controls_panel, map_panel) # Set up event handler for any worker thread results EVT_RESULT(self, self.OnResult) EVT_STOP(self, self.OnStop) # Set up close event so timer is properly stopped wx.EVT_CLOSE(self, self.OnClose) self.reset_gui() self.Show()
class Window(wx.Frame): def __init__(self, parent, title): wx.Frame.__init__(self, parent, title=title) # Splitters and Panels self.controls_map_splitter = wx.SplitterWindow(self) self.controls_map_splitter.SetMinimumPaneSize(300) controls_panel = wx.Panel(self.controls_map_splitter) map_panel = wx.Panel(self.controls_map_splitter) self.graphs_messages_splitter = wx.SplitterWindow(controls_panel) self.graphs_messages_splitter.SetMinimumPaneSize(50) graphs_panel = wx.Panel(self.graphs_messages_splitter) messages_panel = wx.Panel(self.graphs_messages_splitter) # World graphic self._graphics = worldmap.WorldMap(map_panel) self.graphics_sizer = wx.BoxSizer(wx.VERTICAL) self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND) map_panel.SetSizerAndFit(self.graphics_sizer) # Controls panel self.controls = Controls(controls_panel, (300, 250), self) # Info panel self.info = Info(controls_panel, (300, 250)) # Graph canvas self.graphs = graphs.Graphs(graphs_panel, (300, 300)) # Messages panel self.messages = Messages(messages_panel, (600, 200)) self.interface_sizer = wx.BoxSizer(wx.VERTICAL) self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL) self.controls_info_sizer.Add(self.info, 0, wx.EXPAND) self.controls_info_sizer.Add((20, -1), proportion=0) # Padding self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND) self.messages_sizer = wx.BoxSizer(wx.VERTICAL) self.messages_sizer.Add(self.messages, 1, wx.EXPAND) messages_panel.SetSizerAndFit(self.messages_sizer) self.graphs_sizer = wx.BoxSizer(wx.VERTICAL) self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND) graphs_panel.SetSizerAndFit(self.graphs_sizer) self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND) self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND) controls_panel.SetSizerAndFit(self.interface_sizer) self.graphs_messages_splitter.SplitHorizontally( messages_panel, graphs_panel ) self.controls_map_splitter.SplitVertically(controls_panel, map_panel) # Set up event handler for any worker thread results EVT_RESULT(self, self.OnResult) EVT_STOP(self, self.OnStop) # Set up close event so timer is properly stopped wx.EVT_CLOSE(self, self.OnClose) self.reset_gui() self.Show() def reset_gui(self): self.controls.reset_buttons() self.messages.clear() self.graphs.reset_data() # Event Methods def OnStart(self, event): self.controls.set_buttons_ready() self._simulation = simulation.Simulation() self._simulation.setup_config(self.controls.get_config_filename()) self.simulation_info = self._simulation.initialize() if not self.simulation_info.interface_config.print_messages: self.messages.deactivate() self._graphics.num_max_complaints = \ self.simulation_info.num_max_complaints self.rounds = 0 self.steps = 0 self.next_phase = "COASTPLAN" self.prev_phase = None self.worker = None def run(self, rounds, steps): assert rounds >= 0, "Rounds has to be a positive integer." assert steps >= 0, "Steps has to be a positive integer." assert steps > 0 or rounds > 0, "Rounds or steps needs to be positive." self.controls.set_status(rounds, steps) self.controls.set_buttons_processing() self.rounds = rounds self.steps = steps if self.worker is None: self.prev_phase = self.next_phase self.info.set_current_phase(self.next_phase) self.worker = WorkerThread(self._simulation, self) def OnResult(self, event): if not event.source is self.worker: # ongoing simulation was aborted return self.worker = None self.simulation_info.map.grid = util.update_map( self.simulation_info.map.grid, event.result.map.grid ) self.next_phase = event.result.next_phase handle_statistics(self.graphs, event.result.round, event.result.data) self._graphics.set_map(self.simulation_info.map) if event.result.phase == "HEARING": self._graphics.add_votes(event.result.complaints) self._graphics.update() for m in event.result.messages: self.messages.add(str(m)) newr = self.prev_phase == "LEARNING" and self.next_phase == "COASTPLAN" if newr: self._graphics.reset_votes() if newr and self.rounds > 0: self.rounds -= 1 elif self.rounds == 0: self.steps -= 1 if self.rounds > 0 or self.steps > 0: self.run(self.rounds, self.steps) else: self.controls.set_buttons_ready() def OnStop(self, event): self.reset_gui() self._simulation = None self.worker = None self.simulation_info = None def OnClose(self, event): # TODO: Fix self.Destroy()
locale.setlocale(locale.LC_ALL, 'ru_RU.utf-8') sys.path.append('./events') # import main modules from data import Data from say import Say from info import Info from ask import Ask from act import Act # init main modules say = Say() ask = Ask(say) data = Data(ask) info = Info(data) act = Act(data, ask) # import events modules # from market import Market # from distribute import Distribute # from vizier import Vizier from caravan import Caravan # from church import Church # from inheritance import Inheritance # # # init event modules events = [ # Market(), # Distribute(), # Vizier(),