def process_prog(self, data): now = time() if now - Status.rTime > 30: if sys.DEV_MODE: stat = os.statvfs(".") else: stat = os.statvfs("/var/audio") Status.remaining = (stat.f_bsize * stat.f_bavail) / ( (core.depth / 8) * core.channels * core.rate * core.comp_ratio ) Status.rTime = now updateBTimer() updateTemp() save_config() # core.sync_dir() for msg in data: d = json.loads(msg) d["_t"] = "status" # d['c'] = os.getloadavg() d["r"] = Status.remaining d["s"] = core.port.gotSignal() d["ss"] = core.depth d["sr"] = core.rate # d['bt'] = hrBTimer() d["ct"] = int(getTemp()) # if o: self.send(d) Status.pTime = now
def learn_name(name): # build a response response = "Okay {}".format(name) # say it speaker.speak(response) # save the data config.save_config("name", name)
def set_db_message(message): print("保存数据库链接信息") manager.manager.db_address = message["db_addr"] manager.manager.db_dbname = message["db_dbname"] manager.manager.db_password = message["db_password"] manager.manager.db_username = message["db_username"] config.save_config()
def config_editor(): # validation errors errors = {} # values to display in the form values = {} success = None for config_item in config.ALL_ITEMS: values[config_item.key] = config_item.value if request.method == 'POST': for config_item in config.ALL_ITEMS: submitted_value = request.form[config_item.key].strip() error = config_item.validate(submitted_value) if error: errors[config_item.key] = error else: config_item.value = submitted_value values[config_item.key] = submitted_value # Save if there are no errors if not errors: for config_item in config.ALL_ITEMS: config_item.value = values[config_item.key] config.save_config() success = 'Config updated - some settings may not take effect without restarting' return render_template('config_editor.html', ALL_ITEMS=config.ALL_ITEMS, errors=errors, values=values, success=success)
def main(_): # Create a random state using the random seed given by the config. This # should allow reproducible results. tf.reset_default_graph() rng = np.random.RandomState(config.random_seed) tf.set_random_seed(config.random_seed) # Train / Test if config.task == "train": # Import trainer module from trainer import Trainer # Create a trainer object task = Trainer(config, rng) save_config(config.logdir, config) else: # Import tester module from tester import Tester # Create a tester object task = Tester(config, rng) # Run the task task.run()
def process_prog(self, data): now = time() if (now - Status.rTime > 30): if sys.DEV_MODE: stat = os.statvfs('.') else: stat = os.statvfs('/var/audio') Status.remaining = (stat.f_bsize * stat.f_bavail) / ( (core.depth / 8) * core.channels * core.rate * core.comp_ratio) Status.rTime = now updateBTimer() updateTemp() save_config() # core.sync_dir() for msg in data: d = json.loads(msg) d['_t'] = 'status' # d['c'] = os.getloadavg() d['r'] = Status.remaining d['s'] = core.port.gotSignal() d['ss'] = core.depth d['sr'] = core.rate # d['bt'] = hrBTimer() d['ct'] = int(getTemp()) # if o: self.send(d) Status.pTime = now
def start(self): self.show_auth_dialog() self.show_basedir_dialog() self.show_log_path_dialog() self.show_ignore_list_dialog() config.save_config() print('\nAll steps have been gone through.')
def main(_): # Create a random state using the random seed given by the config. This # should allow reproducible results. rng = np.random.RandomState(config.random_seed) tf.set_random_seed(config.random_seed) # Train / Test if config.task == "train": # Import trainer module from trainer import Trainer # Create a trainer object task = Trainer(config, rng) save_config(config.logdir, config) else: # Import tester module if 'hpatch' in cst.DATA: from methods.lift.evaluation.tester_hpatch import Tester print('WARNING: computation on the hpatch dataset') if cst.DATA == 'webcam': from methods.lift.evaluation.tester_webcam import Tester print('WARNING: computation on the webcam dataset') if cst.DATA == 'strecha': from methods.lift.evaluation.tester_strecha import Tester print('WARNING: computation on the strecha dataset') # Create a tester object task = Tester(config, rng) # Run the task task.run()
def do_reset(self,args): if args: self.config[args] = get_default_config()[args] else: self.config = get_default_config() save_config(self.config) self._print_config()
def prune_model(model, train_ds): """ If the bundle entropy is larger than zero, the first conflicting layer and all subsequent layers of the same block type (a, b, c or d) are removed from the architecture. """ print("Start pruning of architecture...", flush=True) conflicts = cb.bundle_entropy(model, train_ds, config.batch_size, config.learning_rate, config.num_classes, config.conflicting_samples_size, all_layers=True) layer = -1 for block_type in range(len(config.pruned_layers)): new_layers = 0 for block_layer in range(config.pruned_layers[block_type]): layer += 1 bundle_entropy_of_layer = conflicts[layer][1] if bundle_entropy_of_layer <= 0: new_layers += 1 #continue config.pruned_layers[block_type] = new_layers save_config(config)
def main(): args = take_args() if args.clear_cache: AnyProvider = providers.WeatherProvider() AnyProvider.Cache_path = config.WEATHER_PROVIDERS['ACCU']['Cache_path'] AnyProvider.clear_cache() del AnyProvider return None if args.u: #sets updating interval config.Caching_time = args.u config.save_config(config.CONFIG) return None if args.accu: Accu = providers.AccuProvider() Accu.initiate(config.WEATHER_PROVIDERS['ACCU']) run_app(args, Provider=Accu, forec=args.forec) if args.rp5: RP5 = providers.RP5_Provider() RP5.initiate(config.WEATHER_PROVIDERS['RP5']) run_app(args, Provider=RP5, forec=args.forec) if args.sin: Sinoptik = providers.SinoptikProvider() Sinoptik.initiate(config.WEATHER_PROVIDERS['Sinoptik']) run_app(args, Provider=Sinoptik, forec=args.forec) if args.csv: save_csv(config.ACTUAL_WEATHER_INFO, args.csv) if args.save: save_txt(config.ACTUAL_PRINTABLE_INFO, args.save) config.save_config(config.CONFIG)
def do_reset(self, args): if args: self.config[args] = get_default_config()[args] else: self.config = get_default_config() save_config(self.config) self._print_config()
def set_config(self): self.config["ip"] = self.hostVar.get() self.config["password"] = self.passwordVar.get() self.config["path"] = self.pathVar.get() self.config["localPath"] = self.localPathVar.get() self.config["user"] = self.userVar.get() save_config(self.config)
def run(self): config.log.info('syncer starts running') self.conn = sqlite3.connect(DAEMON_DB_PATH, isolation_level = None) self.conn.row_factory = sqlite3.Row self.cursor = self.conn.cursor() # when switch is set, the thread should stop while not self.switch.is_set(): # block until there is something in the queue self.empty_lock.wait() # clear task queue while not self.switch.is_set() and not self.queue.empty(): entry = self.queue.get() try: self.merge_dir(entry) except live_api.AuthError as e: config.log.error(e.__class__.__name__ + ': ' + str(e)) app_tokens = self.api.refresh_token(config.APP_CONFIG['token']['refresh_token']) self.api.set_access_token(app_tokens['access_token']) config.save_token(app_tokens) config.save_config() self.enqueue(entry[0], entry[1]) except live_api.NetworkError: config.log.error('Network error. Wait for {} seconds.'.format(NETWORKERR_WAIT_INTERVAL)) time.sleep(NETWORKERR_WAIT_INTERVAL) self.enqueue(entry) self.queue.task_done() self.empty_lock.clear() config.log.debug('queue is now empty.') self.conn.close() config.log.info('syncer stops.')
def main(): while 1: current_ip = get_ip() if current_ip: # 对于拥有多个出口 IP 负载均衡的服务器,上面的 get_ip() 函数会在几个 ip 之间不停切换 # 然后频繁进入这个判断,进行 update_record(),然后很快就会触发 API Limited 了 # 于是建立一个IP池记载这个服务器的几个出口IP,以免频繁切换 ip_count = int(cfg['ip_count']) ip_pool = cfg['ip_pool'].split(',')[:ip_count] cfg['current_ip'] = current_ip if current_ip not in ip_pool: # new ip found logging.info("new ip found: %s", current_ip) ip_pool.insert(0, current_ip) cfg['ip_pool'] = ','.join([str(x) for x in ip_pool[:ip_count]]) try: update_record() save_config() except Exception as e: logging.warning('update_recoud or save_config failed: %s', str(e)) else: logging.error('get current ip FAILED.') try: interval = int(cfg['interval']) except ValueError: interval = 5 # await asyncio.sleep(interval) time.sleep(interval)
def show_auth_dialog(self): print('=' * 30) if not query_yes_no( 'Do you want to authorize onedrive-d to access your OneDrive account?' ): print(' Skipped.') return print( '\nYou will need to visit the OneDrive authorization page manually, ' ) print( 'log in and authorize the onedrive-d, and then copy and paste the ' ) print('callback URL, which should start with \n"%s".\n' % self.api.client_redirect_uri) print( 'The callback url is the URL when the authorization page finally goes blank.\n' ) print('Please visit the authorization page via URL:\n') print(self.api.get_auth_uri()) callback_uri = input('\nPlease paste the callback URL:\n') try: app_tokens = self.api.get_access_token(uri=callback_uri) config.save_token(app_tokens) config.save_config() print('\nonedrive-d has been successfully authorized.') except OneDrive_Error as e: print( 'CRITICAL: failed to authorize the client with the given URL.') print('%s' % e)
def handle(self, event_id, event_args=None): print('Dialog object received {} event.'.format(event_id)) if event_id == 'refresh_code': app_tokens = self.api.get_access_token(uri=event_args) config.save_token(app_tokens) config.save_config() elif event_id == 'child_close': pass
def get_user_auth(self, f): x = XMLBuilder('QUERIES') with x.QUERY(cmd='REGISTER'): x.CLIENT(self.CLIENT_ID_TAG) response = self.query_eyeq(x) self.USER = response['USER'] self.config.USER = self.USER save_config(f, self.config)
def apply_gray_change(cf, current_set, gray_max, sw, im_num): if gray_max != current_set[0]: save_config("scan", "gray_max", gray_max) cf["gray_max"] = gray_max if sw != current_set[1]: im_num = -1 cv2.setTrackbarPos('Restart', 'Laser Line', 0) return im_num
def toggle_play_practice(self): if self.play_practice_button['background'] == "#00ff00":#color is green, so user is disabling self.play_practice_button.configure(background="#ff0000") defines.PLAY_PRACTICE=False else:#color is red, so user is enabling self.play_practice_button.configure(background="#00ff00") defines.PLAY_PRACTICE=True save_config()
def toggle_random_attack(self): if self.random_attack_button['background'] == "#00ff00":#color is green, so user is disabling self.random_attack_button.configure(background="#ff0000") defines.RANDOM_ATTACKS=False else:#color is red, so user is enabling self.random_attack_button.configure(background="#00ff00") defines.RANDOM_ATTACKS=True save_config()
def resizeEvent(self, event: G.QResizeEvent) -> None: super(MainWindow, self).resizeEvent(event) maximized = self.isMaximized() config.config['maximized'] = maximized if not maximized: config.config['width'] = self.width() config.config['height'] = self.height() config.save_config()
def change_brightness(self): value = config.get_brightness() value += 1 if value > 15: value = 7 self.get_system().pmu.setScreenBrightness(value) config.save_config("brightness", value) print("set and save brightness value to", value)
def toggle_move_mouse(self): if self.mouse_button['background'] == "#00ff00":#color is green, so user is disabling self.mouse_button.configure(background="#ff0000") defines.USE_MOUSE=False else:#color is red, so user is enabling self.mouse_button.configure(background="#00ff00") defines.USE_MOUSE=True save_config()
def toggle_play_ranked(self): if self.play_ranked_button['background'] == "#00ff00":#color is green, so user is disabling self.play_ranked_button.configure(background="#ff0000") defines.PLAY_RANKED=False else:#color is red, so user is enabling self.play_ranked_button.configure(background="#00ff00") defines.PLAY_RANKED=True save_config()
def toggle_mulligan(self): if self.mulligan_button['background'] == "#00ff00":#color is green, so user is disabling self.mulligan_button.configure(background="#ff0000") defines.MULLIGAN=False else:#color is red, so user is enabling self.mulligan_button.configure(background="#00ff00") defines.MULLIGAN=True save_config()
def toggle_quest_reroll(self): if self.quest_button['background'] == "#00ff00":#color is green, so user is disabling self.quest_button.configure(background="#ff0000") defines.REROLL_QUESTS=False else:#color is red, so user is enabling self.quest_button.configure(background="#00ff00") defines.REROLL_QUESTS=True save_config()
def save_in_telegram(twitter_msg, context): """ Saves a tweet and video in Telegram (with a archive.is link) :param twitter_msg: Twitter Status Object :param context: Telegram bot context :return: nothing """ tweet_url = "https://www.twitter.com/{}/status/{}".format( twitter_msg.user.screen_name, twitter_msg.id) logging.info("Saving tweet {}".format(tweet_url)) if twitter_msg.media is not None: saved_url = archive.save_in_archive(tweet_url) config.save_config() location = tweets.get_geo(twitter_msg) caption = "{} {}".format(saved_url, location) msg = None if saved_url is not None: # Individual file if len(twitter_msg.media) == 1: m = twitter_msg.media[0] if m.type == "photo": msg = context.bot.send_photo(config.config["telegram"]["chatid"], m.media_url_https, disable_notification=True, caption=caption) elif m.type == "video": best_variant = tweets.get_best_variant(m.video_info["variants"]) if best_variant is not None: msg = context.bot.send_video(config.config["telegram"]["chatid"], best_variant, disable_notification=True, caption=caption) elif len(twitter_msg.media) > 1: mediaArr = [] for m in twitter_msg.media: if m.type == "photo": mediaArr.append(telegram.InputMediaPhoto(media=m.media_url_https, caption=saved_url)) elif m.type == "video": best_variant = tweets.get_best_variant( m.video_info["variants"]) if best_variant is not None: mediaArr.append(telegram.InputMediaVideo(media=best_variant, caption=saved_url)) resps = context.bot.send_media_group(config.config["telegram"]["chatid"], mediaArr, disable_notification=True) if len(resps) > 0: msg = resps[0] config.config["cached"][str(twitter_msg.id)] = { "archive_url": saved_url, "telegram_url": msg.link } config.save_config() else: logging.info("error saving tweet {}") return msg
def _commit(self) -> None: config.config['last_target_dir'] = self.get_target_directory() config.config['decimals'] = self.get_decimals() config.config['prefix'] = self.get_prefix() config.config['copy'] = self.is_copy() size = self.size() config.config['apply_dialog_width'] = size.width() config.config['apply_dialog_height'] = size.height() config.save_config()
def configure(): """loads, configures, and saves runtime configuration""" cfg = config.load_config() config.set_port(cfg) config.set_baud(cfg) config.set_update_rate(cfg) #config.set_channel(cfg) config.set_write_key(cfg) config.save_config(cfg)
def set_answer(update,context): if update.message.from_user.id == CONFIG['Admin'] : try: CONFIG['Feedback_answer'] = context.args[0] config.save_config() update.message.reply_text('反馈消息已经更新为:%s' % CONFIG['Feedback_answer']) return except (IndexError, ValueError): update.message.reply_text('使用说明: /setanswer 赞了一把,踩了一脚,吐了一地\n请使用逗号将每个按钮的反馈消息分开')
def unban(user_id): """ allows to unban an user :param user_id: :return: """ if str(user_id) in config.config["users"]: del config.config["users"][str(user_id)] config.save_config()
def set_startup_file(self): layer_paths = [] for layer in self.image_area: layer_paths.append(layer.file_path) dialog = SetStartupDialog(layer_paths,self) retval = dialog.exec_() path = layer_paths[retval] self.manager.system.startup_file_path = path cfg.save_config(self.startup_dir, self.manager, True)
def set_feedback(update,context): if update.message.from_user.id == CONFIG['Admin'] : try: CONFIG['Feedback_text'] = context.args[0] config.save_config() update.message.reply_text('反馈按钮已经更新为:%s' % CONFIG['Feedback_text'] ) return except (IndexError, ValueError): update.message.reply_text('使用说明: /setfeedback 👍,👎,🤮\n请使用逗号将按钮分开')
def set_master_key(): config_object = config.load_config(GLOBAL_CONFIG_FILEPATH) section = "MAPAdmin" if section not in config_object.sections(): config_object.add_section(section) master_key = raw_input("Enter the master key : ") if master_key != "": config_object = config.set_user_items( config_object, section, {"MAPILLARY_SECRET_HASH": master_key}) config.save_config(config_object, GLOBAL_CONFIG_FILEPATH) return master_key
def config_deckbutton(self): deck=self.current_deckopt_num if self.deck_buttons[deck]['background'] == "#00ff00":#color is green, so user is disabling self.deck_buttons[deck].configure(background="#ff0000") self.deckopt_button.configure(background="#ff0000",text="Deck %i Disabled"%(deck+1)) defines.DECKS_TO_USE.remove(deck) else:#color is red, so user is enabling self.deck_buttons[deck].configure(background="#00ff00") self.deckopt_button.configure(background="#00ff00",text="Deck %i Enabled "%(deck+1)) defines.DECKS_TO_USE.append(deck) save_config()
def set_quit(self): """退出播放""" self.q = True self.player.quit() subprocess.call('echo -e "\033[?25h";clear', shell=True) logger.debug("Terminal reset.") # store the token and the default info self.douban.login_data.update({"volume": self._volume, "channel": self._channel}) logger.info(self.douban.login_data) config.save_config(self.history, self.douban.login_data) sys.exit(0)
def delete_file(filename): """Remove a file""" filename = os.path.basename(filename) # FIXME: possible race condition if os.path.exists(secure_path(cagibi_folder, filename)) and filename in files_info: os.remove(secure_path(cagibi_folder, filename)) del files_info[filename] save_config(files_info, filename="files.json") return "Ok." else: abort(500, "File doesn't exist or is not in database.")
def name_input(): clear() is_valid = False while not is_valid: try: choice = input('\n\n Enter your project name : ') is_valid = True except ValueError as err: print(("'%s' is not a valid name." % err.args[0].split(": ")[1])) name = get_available_name(choice) print("\n\nYour project name is {0}\n\n".format(name)) save_config("scan", "name", name)
def save_config(data): json_obj = json.loads(data) config_dict = {} for section in json_obj: section_content = {} for key in json_obj[section]['config']: section_content[key] = json_obj[section]['config'][key] config_dict[json_obj[section]['name']] = section_content config.save_config(config_dict) # reload the config ConfigSingleton({ConfigElements.YOUTUBE_API_KEY.value: config.get_value_from_config(ConfigElements.YOUTUBE_API_KEY.value, Section.GENERAL), ConfigElements.VIDEO_DIRECTORY.value: config.get_value_from_config(ConfigElements.VIDEO_DIRECTORY.value, Section.GENERAL)})
def cam_number_input(): clear() is_valid = False while not is_valid: try: print('Enter your camera device number,') print('Get it with "uvcdynctrl -l"') choice = input('\n\n Camera device number :') is_valid = True except ValueError as err: print(("'%s' is not a valid name." % err.args[0].split(": ")[1])) save_config("scan", "cam", choice) print("\n\nYour camera device number is {0}\n\n".format(choice))
def apply_cursor_change(self, conf, new, trackbar_name, ini_name): # Save in conf dict conf[ini_name] = new # Apply cam settings if cam parameter if self.section == conf["webcam"]: print "apply" # apply_cam_setting("Brightness" = trackbar_name, new) # with trackbar_name = trackbarList[0][0] apply_cam_setting(int(conf["cam"]), trackbar_name, new) # Save in scan.ini # save_config(section, "brightness" = trackbarList[0][1], value) if self.section: # HD5000 255 29 save_config(self.section, ini_name, new)
def remove_website(args): user_config = config.get_config() try: site = user_config["websites"][args.WEBSITE] except KeyError: print("") print("Unknown website configuration : {0}".format(args.WEBSITE)) print("") else: del user_config["websites"][args.WEBSITE] config.save_config(user_config) print("") print("Local website configuration removed : {0}".format(args.WEBSITE)) print("")
def do_set(self,args): if not args: self._print_config() else: try: arglist = re.split(r' +',args) k = arglist[0] v = ' '.join(arglist[1:]) set_config_key(self.config,k,v) save_config(self.config) self._print_config() except ValueError: print 'Syntax error: %s' % args except: raise
def name_input(cf): clear() is_valid = 0 while not is_valid : try : choice = input('\n\n Enter your project name : ') is_valid = 1 except ValueError as e : print(("'%s' is not a valid name." % e.args[0].split(": ")[1])) name = get_available_name(choice) print("Your project name is {0}".format) cf["name"] = name save_config("scan", "name", name) # Create directory, variable with this name conf = load_config("./scan.ini")
def create_file(filename): """Create a file on the server. The method receives two POST parameters: - filename : the filename - contents : the contents """ #FIXME: handle directories filename = os.path.basename(filename) contents = request.forms.get('contents') # FIXME: possible race condition if not os.path.exists(filename) and filename not in files_info: fd = open(secure_path(cagibi_folder, filename), "wb") fd.write(contents) fd.close() files_info[filename] = {"rev": 1} save_config(files_info, filename="files.json") return "Ok." else: abort(400, "File already exists")
def filelist(): """return a list of files with some metadata""" folder = {} files_info = load_config(filename="files.json") for file in os.listdir(cagibi_folder): folder[file] = {} folder[file]["mtime"] = os.path.getmtime(secure_path(cagibi_folder, file)) if file not in files_info: # Automatically add new files files_info[file] = {} files_info[file]["rev"] = 1 # FIXME: don't save the data for every new file. save_config(files_info, filename="files.json") folder[file]["rev"] = files_info[file]["rev"] return json.dumps(folder)
def btnConfig(self, event=None): import configEditor as ce import config import organ_segmentation as los d = los.lisa_config_init() root = tk.Tk() conf = ce.apply(root, d, (0, 2, 0, 0), use_list=False) root.mainloop() newconf = {} for (k, v) in conf.iteritems(): key = str(k) value = str(v.get()) try: value = eval(value) except: pass newconf[key] = value config.save_config(newconf, os.path.join(newconf["output_datapath"], "organ_segmentation.config")) self.quit(event)
def get_plays(self, config_name, user): if self.account != "" and self.password != "": self.__sign(self.account, self.password) playlist = load_config(config_name) for play in playlist: alluri = "" webpage = get_url(play["url"], self.headers) seasons = sort_plays(self.__get_play_from_webpage(webpage, play)) for season in seasons: for episode in seasons[season]: uri = seasons[season][episode] alluri += uri + "\n\r" play['season'] = season play['episode'] = episode save_uri("zimuzu", alluri, user) save_config(playlist, config_name) time.sleep(10)
def get_plays(self, config_name, user): playlist = load_config(config_name) for play in playlist: alluri = "" allname = "" seasons = sort_plays(self.get_play_from_webpage(play)) for season in seasons: for episode in seasons[season]: uri = seasons[season][episode] alluri += uri + "\n\r" allname += str(play['name']) + " ep:" + str(episode) + "\n\r" # play['season'] = season play['episode'] = episode save_uri("dmhy", alluri, user) save_config(playlist, config_name) sleep(15)
def update_file_hashes(filename): """Updates a file using the deltas received by a client""" deltas = decode_deltas(json.loads(request.forms.get("deltas"))) unpatched = open(secure_path(cagibi_folder, filename), "rb") save_to = os.tmpfile() patchstream(unpatched, save_to, deltas) unpatched.close() os.unlink(secure_path(cagibi_folder, filename)) save_to.seek(0) # FIXME: rename instead of copying ? file_copy = open(secure_path(cagibi_folder, filename), "w+b") file_copy.write(save_to.read()) file_copy.close() save_to.close() files_info[filename] = {"rev": files_info[filename]["rev"] + 1} save_config(files_info, filename="files.json") return files_info[filename]
def main(): # Handle configurations home_path = os.path.join(os.path.expanduser("~"), ".irk") config_path = os.path.join(home_path, "config") client_config_file = os.path.join(config_path, "client.conf") bot_config_file = os.path.join(config_path, "bot.conf") if not os.path.exists(home_path): os.mkdir(home_path) if not os.path.exists(config_path): os.mkdir(config_path) if not os.path.exists(client_config_file): client_config = config.interactive_build_config(default_client_config) config.save_config(client_config_file, client_config) else: client_config = config.load_config(client_config_file) if not os.path.exists(bot_config_file): bot_config = config.interactive_build_config(default_bot_config) config.save_config(bot_config_file, bot_config) else: bot_config = config.load_config(bot_config_file) # Retroactively patch home_path into configurations. client_config['home_path'] = home_path bot_config['home_path'] = home_path client_proc = Client(client_config) bot_proc = Bot(bot_config) client_proc.connect_queues(bot_proc) client_proc.start() bot_proc.start() client_proc.join() bot_proc.join()
def btnConfig(self, event=None): import config import organ_segmentation as los import lisaConfigGui as lcg d = los.lisa_config_init() newconf = lcg.configGui(d) if newconf is None: # reset config os.remove( os.path.join( d['output_datapath'], 'organ_segmentation.config') ) else: config.save_config( newconf, os.path.join( newconf['output_datapath'], 'organ_segmentation.config') ) self.quit(event)