def _as_settings(args): mode = args.mode if mode: mode = mode.upper() if mode == 'NEURONS': settings = presets.NEURONS elif mode == 'MOVING_NEURONS': settings = presets.MOVING_NEURONS elif mode == 'HAPPY': settings = presets.HAPPY elif mode == 'QUICK': settings = presets.QUICK elif mode == 'SMALL_RINGS': settings = presets.SMALL_RINGS elif mode == 'DROPS': settings = presets.DROPS elif mode == 'SMALL': settings = presets.SMALL else: settings = Settings( max_bubble_radius=args.max_radius, random_color=(not args.purple_color), bubble_speed=args.speed) settings.full_screen = args.fullscreen settings.DEBUG = args.debug return settings
def main(): """main() - main function Args: None. Returns: Nothing. """ parse_args() # TODO load previous state from disk for _ in range(LOG.size): LOG.add((None, [])) # Set up HTTP API wwwroot = Resource() wwwroot.putChild(b"", PingerAPIHelp()) wwwroot.putChild(b"elapsed", PingerAPIElapsed()) wwwroot.putChild(b"check", PingerAPICheck()) wwwroot.putChild(b"up", PingerAPIUp()) wwwroot.putChild(b"down", PingerAPIDown()) wwwroot.putChild(b"stats", PingerAPIStats()) reactor.listenTCP(Settings.get("port"), server.Site(wwwroot)) # START THE REACTOR!@#$ reactor.callInThread(check_hosts, Settings.get("hosts")) reactor.run()
def settings(tmpdir): settings = Settings(tmpdir) vdot = VDOT(settings.database, settings.vdot) vdot.calculate_vdot('HalfMarathon', '01:36:40') vdot.save_vdot() settings.get_settings() return settings
class PurgeRecordings: def __init__(self): self.settings = Settings() self.config = self.settings.load_config() self.settings.init_logging('purge_recordings', prefix_date=True, stdout=True) def __enter__(self): pass def __exit__(self, exc_type, exc_val, exc_tb): pass def get_locations(self, open_web_if): locations_list = [] locations = open_web_if.get_locations() for key, value in locations.items(): for key2, value2 in value.items(): locations_list.append(value2) return locations_list def days_old(self, dt, now): delta = now - dt return delta.days def main(self): logger.info("Starting a new run") news_re = re.compile('Nine News') now = datetime.datetime.now() purge_older_than_days = int(self.config.get('BEYONWIZ', 'purge_older_than_days')) logger.info("Purging recordings older than {} days".format(purge_older_than_days)) open_web_if = OpenWebIf(self.config.get('BEYONWIZ', 'host'), 80) locations = self.get_locations(open_web_if) for location in locations: movies = open_web_if.get_movies(location) e2movies = movies['e2movielist']['e2movie'] for movie in e2movies: if news_re.search(movie['e2title']): dt = datetime.datetime.fromtimestamp(int(movie['e2time'])) days_old = self.days_old(dt, now) logger.info("{} - {}, {} days old".format(movie['e2title'], dt.strftime("%d/%m/%Y %H:%M"), days_old)) if days_old > purge_older_than_days: logger.info("Purging {} - {}".format(movie['e2title'], dt.strftime("%d/%m/%Y %H:%M"))) result = open_web_if.delete_movie(movie['e2servicereference']) if 'e2simplexmlresult' in result: if 'e2state' in result['e2simplexmlresult']: if result['e2simplexmlresult']['e2state']: logger.info("Deleted: {} - {}".format(movie['e2title'], dt.strftime("%d/%m/%Y %H:%M"))) else: logger.error("Failed deleting: {} - {} => {}".format( movie['e2title'], dt.strftime("%d/%m/%Y %H:%M"), result['e2simplexmlresult']['e2statetext'] )) else: logger.error(result) else: logger.error(result)
def __is_parsed(result: float, is_learing_on: bool, settings: Settings): if result is None: return False # TODO: we use 0 in both cases, but originally it was two different settings if is_learing_on: parsing_threshold = float(settings.get_value('sgcs', 'parsing_threshold')) else: parsing_threshold = float(settings.get_value('sgcs', 'parsing_threshold')) return result > parsing_threshold
def __compute_new_tmp_value(cell_rule_1: CellRule, cell_rule_2: CellRule, settings: Settings) -> float: """ Takes the temporary values of the rule parents and calculates new temporaty value :param cell_rule_1: First parent of the checked rule :param cell_rule_2: Second parent of the checked rule :return: """ return cell_rule_1.tmp_val * float( settings.get_value('rules', 'base_amount_reduction_coefficient')) \ + cell_rule_2.tmp_val * float( settings.get_value('rules', 'base_amount_reduction_coefficient'))
def __init__(self, files_list, root_path=None): if (root_path == None): root_path = path.abspath( path.join( path.abspath( path.dirname( path.abspath( inspect.getfile(inspect.currentframe())))), "..")) self.logger = Logger(root_path) self.settings = Settings(root_path) self.context = Context(self.settings) for filepath in files_list: self.context.load_path(filepath)
def prepare_local(): settings = Settings() for key in ('ars', 'cpp_polygons_executables', 'L_div_outer_r', 'disk_thickness', 'vertices_number', 'mixing_steps', 'max_attempts', 'cpp_settings_fname', 'required_settings', 'cpp_directory', 'moduli', 'FEMFolder', 'memory', 'limitation_memory_ratio', 'taus', 'disk_thickness', 'fi_limitation'): self.initial_settings[key] = settings[key] wd = '_'.join([self.__class__.__name__, self.remote_wd_short]) if 'working_directory' in kwargs.keys(): wd = kwargs['working_directory'] self.initial_settings['working_directory'] = wd self.wd = wd + '/' if wd not in os.listdir(): os.mkdir(wd) os.chdir(wd) self.initial_settings['task_name'] = kwargs['task_name'] asc_time = time.asctime().split() self.year_month_day = '_'.join( [asc_time[4], asc_time[1], asc_time[2]]) self.py_main_log = 'py_main_log_' + self.year_month_day for dirname in ['logs', 'geo', 'files']: if dirname not in os.listdir(): os.mkdir(dirname) self.ssh = paramiko.SSHClient() self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.ssh.connect(ClusterSettingsKiaeMe().host, username=ClusterSettingsKiaeMe().user, password=ClusterSettingsKiaeMe().pwd, key_filename=ClusterSettingsKiaeMe().key)
def __init__(self, jupyter=False): if len(sys.argv) not in range(3, 6): print( "Please set parameters to run app.\nParams: <app_settings_file> <logger_settings_file>" ) sys.exit(1) if jupyter: self.__config_app = 'app.ini' self.__config_logger = 'logger.ini' else: self.__config_app = sys.argv[1] self.__config_logger = sys.argv[2] if os.path.isfile(self.__config_app) and os.path.isfile( self.__config_logger): #logging.config.fileConfig(self.__config_logger) self.__logger = logging.getLogger("main") self.__settings = Settings(self.__config_app) self._path = "{}/../Charts/data/*.json".format( os.path.dirname(os.path.abspath(__file__))) self.report_generator = ReportGenerator(self.__settings) files = glob.glob(self._path) for f in files: os.remove(f) else: print("Please set valid config paths") sys.exit(1) self.json_data = json.load(open("./NewTestSets/induced_grammars.json"))
def __init__(self, parallelData, grammar: sGCSGrammar, is_learning_on: bool, sentence: str, settings: Settings, start_covering: Covering = None, final_covering: Covering = None, aggressive_covering: Covering = None, terminal_covering: Covering = None): self.grammar = grammar self.is_learning_on = is_learning_on self.default_value = None self.probability_array = None self.sentence = sentence self.positive = False self.sequence = [] self.rules_table = None self.mode = settings.get_value('general', 's_mode') self.settings = settings self.is_parsed = False self.start_covering = start_covering self.final_covering = final_covering self.aggressive_covering = aggressive_covering self.terminal_covering = terminal_covering self.parallelData = parallelData self.parallelData.values['sentence'] = self.sentence self.parallelData.values[ 'start_system_index'] = self.grammar.get_start_symbol().index self.parallelData.values['positive'] = self.positive self.parallelData.values[ 'full_covering_allowed'] = self.settings.get_value( 'covering', 'is_full_covering_allowed') == "True"
def __init__(self): # Settings self.settings = Settings() self.settings.load() self.screen = window(self.settings) self.running = True self.clock = pygame.time.Clock() self.fps = self.settings.fps self.dt = self.clock.tick(self.fps) / 1000 self.last_screen = [0, 0] self.fps_label = Text(self.screen, int(self.clock.get_fps()), [0, 0, 50, 50], font_size=35)
def __init__(self, just_watch=True): self.pid = os.getpid() self.just_watch = just_watch settings = Settings() self.tracked_names = settings['time_limits'].keys() self.period = settings['period'] print('started watching, self pid={0}'.format(self.pid), ', just_watch={0}'.format(self.just_watch), ', period = {0}'.format(self.period)) print('tracked names', *self.tracked_names) while True: value = self.check_for_long_processes() if value in self.check_return_values.values(): for k, v in self.check_return_values.items(): if v == value: print(k) if k == 'processes_not_found': print('exiting due to the absence of the tracked', 'processes') sys.exit() else: print('error: unknown return code of check_for_long_processes') print(value) sys.exit() time.sleep(self.period)
def __init_first_row(cyk_values: CykValues, is_sentence_positive: bool, settings: Settings): for i in range(len(cyk_values.sequence)): covering = None was = False # TODO: dictionary can fasten this search for rule in cyk_values.grammar.get_rules(): if rule.right1 == cyk_values.sequence[i]: rule: sRule = rule was = True __init_cell(cyk_values, i, rule) rule.tmp_used = True cyk_values.rules_table[0][i].append(sCellRule(rule)) if not was and is_sentence_positive: if len(cyk_values.sequence) > 1: covering = cyk_values.terminal_covering elif settings.get_value('covering', 'is_start_covering_allowed') == "True": covering = cyk_values.start_covering if covering is not None: new_rule = covering.add_new_rule(cyk_values.grammar, cyk_values.sequence[i]) new_rule.tmp_used = True __init_cell(cyk_values, i, new_rule) cyk_values.rules_table[0][i].append(sCellRule(new_rule)) cyk_values.parallelData.cyk_parsed_cells['{}{}'.format(0, i)] = True cyk_values.parallelData.cyk_rules_for_cell['{}{}'.format(0, i)] = cyk_values.rules_table[0][i] cyk_values.parallelData.cyk_probability_array['{}{}'.format(0, i)] = cyk_values.probability_array[0][i]
def get_crowding(settings: Settings) -> Crowding: crowding_enabled = settings.get_value('crowding', 'crowding_enabled') == "True" if crowding_enabled: return StandardCrowding(settings) else: return DummyCrowding(settings)
def test_Estimate(self): random.seed(23) self.__settings = Settings('test_app.ini') self.__gcs = sGCS(self.__settings) self.__stochastic = Stochastic() abbading_format_loader = AbbadingoFormatLoader() abbading_format_loader.load('../../NewTestSets/TomitaNew/tomita_1.txt') self.__gcs.train_data = abbading_format_loader.input_data self.__gcs.reset_grammar() non_terminal_rules = set() non_terminal_rules = deepcopy(self.__gcs.grammar.get_non_terminal_rules()) for rule in non_terminal_rules: self.__gcs.grammar.remove_rule(rule) n_symbols = self.__gcs.grammar.nonTerminalSymbols t_symbols = self.__gcs.grammar.terminalSymbols self.__gcs.grammar.add_rules([sRule([n_symbols[0], n_symbols[0], n_symbols[1]], prob=random.uniform(0, 1)), sRule([n_symbols[0], n_symbols[0], n_symbols[2]], prob=random.uniform(0, 1)), sRule([n_symbols[1], t_symbols[1]], prob=random.uniform(0, 1)), sRule([n_symbols[2], t_symbols[0]], prob=random.uniform(0, 1)), sRule([n_symbols[0], t_symbols[1]], prob=random.uniform(0, 1)), sRule([n_symbols[0], t_symbols[0]], prob=random.uniform(0, 1))]) all_rules = self.__gcs.grammar.get_rules() are_terminals = [rule.is_terminal(AaaRulesHandlingType.TERMINALS) for rule in all_rules] loader_widget = widgets.IntProgress(value=0, min=0, step=1, bar_style='info', orientation='horizontal', layout=widgets.Layout(width='100%', height='100%'), style={'description_width': 'initial'}) self.__stochastic.normalize(self.__gcs.grammar) self.__gcs.process(True, loader_widget) all_rules = self.__gcs.grammar.get_rules() pass
def __init__(self): st = Settings() self.settings = st.load() self.host = self.settings['redis_host'] self.port = self.settings['redis_port'] self.db = redis.StrictRedis(host=self.host, port=self.port, charset="utf-8", decode_responses=True) self.collection_tasks = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_tasks'] self.collection_log = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_log'] self.collection_cve = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_cve'] self.collection_cpe = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_cpe'] self.collection_cwe = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_cwe'] self.collection_cpeother = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_cpeother'] self.collection_whitelist = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_whitelist'] self.collection_blacklist = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_blacklist'] self.collection_info = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_info'] self.collection_ranking = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_ranking'] self.collection_via4 = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_via4'] self.collection_capec = self.settings[ 'redis_collection_name'] + ':' + self.settings[ 'redis_collection_capec'] self.complete_flag = self.settings['redis_complete_flag']
def __update_rules_count_after_sentence_parsing(cyk_values: CykValues, learning_on: bool, cyk_start_cell_rules, cyk_start_cell_rules_probability, positive: bool, settings: Settings): if learning_on and settings.get_value('covering', 'is_terminal_covering_allowed') == "True": sentence_probability = __calculate_sentence_probability(cyk_values, cyk_start_cell_rules, cyk_start_cell_rules_probability, positive) for rule in cyk_values.grammar.get_rules(): rule: sRule = rule rule.calculate_counts(sentence_probability)
def get_start_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'start_covering_type') if covering_type == "covering_plus": return StartCoveringPlus() elif covering_type == "standard_covering": return StartStandardCovering() else: raise RuntimeError("No start covering selected")
def get_final_covering(settings: Settings, crowding: Crowding = None) -> Covering: covering_type = settings.get_value('covering', 'final_covering_type') if covering_type == "covering_plus": return FinalCoveringPlus(crowding) elif covering_type == "standard_covering": return FinalStandardCovering(crowding) else: raise RuntimeError("No final covering selected")
def __init_rules_value(cyk_values: CykValues, settings: Settings): """ Initiates the base amount of the first row of rules table :param sentence_length: length of the given sentence :return: """ for i in range(len(cyk_values.sentence)): for j in range(len(cyk_values.rules_table[0][i].cell_rules)): cyk_values.rules_table[0][i].cell_rules[j].tmp_val = float(settings.get_value('rules', 'base_amount'))
def get_heuristic(settings: Settings, crowding: Crowding = None) -> Heuristic: heuristic_algorithm = settings.get_value('general', 'heuristic_algorithm') if heuristic_algorithm == "ga": return GeneticAlgorithm(crowding, settings) elif heuristic_algorithm == "split_and_merge": return SplitAndMerge(settings=settings) else: raise RuntimeError("No heuristic algorithm selected")
def test_remove_the_best_rules_when_elite_number_right(self): self.crowding.settings = Settings('') self.crowding.settings.get_value = MagicMock(return_value=2) self.crowding.elite_rules_number = 2 rules = self.crowding.remove_the_best_rules(self.rules) self.assertTrue(rules.__contains__(self.rule_5)) self.assertTrue(rules.__contains__(self.rule_4)) self.assertTrue(rules.__contains__(self.rule_3)) self.assertFalse(rules.__contains__(self.rule_2)) self.assertFalse(rules.__contains__(self.rule_1))
def __init__(self, application): super(Controller, self).__init__() self._created_displays_counter = 0 self._animations = {} self._popup = None self._settings = Settings(self, 'DynamicsToolBox', 'UserSettings', location='settings') self._serializer = Serializer(self) last_session = self.auto_load_workspace() self._playback_widget = PlaybackWidget() self._signal_tree_main = SignalTree( controller=self, hidden_properties=self.settings.hidden_columns_main, ) self._signal_tree_popup = SignalTree( controller=self, hidden_properties=self.settings.hidden_columns_popup, ) self._data_store = DataStore( controller=self, last_session=last_session.get('data_store') if last_session else None, ) self._playback_manager = PlaybackManager( controller=self, playback_widget=self._playback_widget, playback_hz=30, ) self._gui = MainWindow( controller=self, playback_widget=self._playback_widget, signal_tree=self._signal_tree_main, last_layout=last_session.get('layout') if last_session else None, ) self._signal_tree_main.signal_request_width.connect( self._gui.set_signal_tree_width) self._data_store.data_store_changed.connect(self.update_data_views) if self.settings.geometry: self._gui.restoreGeometry(self.settings.geometry) # TODO I think inheriting from EditAndDebug is pointless. # The children widgets are really the ones that should inherit from some kind of Editable class self.edit_mode = self.settings.edit_mode self.debug_mode = self.settings.debug_mode self.main_window.show() self.update_data_views()
def summary(): print("------------------") print("Engine mode is " + str(Settings.get_engine_mode())) print("Image logger is " + str(image_logging.state)) if image_logging.state == image_logging.state.ON: print("Image logger prefix: " + image_logging.get_dir_path()) print("Image display is " + str(image_display.state)) print("Dataset creator is " + str(interactive_dataset_creator.state)) if interactive_dataset_creator.state == interactive_dataset_creator.State.ON: print("Dataset prefix: " + interactive_dataset_creator.dataset_prefix) print("------------------")
def __init__(self, files_list, root_path = None): if (root_path == None): root_path = path.abspath(path.join( path.abspath(path.dirname( path.abspath(inspect.getfile( inspect.currentframe())))), "..")) self.logger = Logger(root_path) self.settings = Settings(root_path) self.context = Context(self.settings) for filepath in files_list: self.context.load_path(filepath)
def __init__(self): if len(sys.argv) != 2: print( "Please set parameters to run app.\nParams: <app_settings_file>" ) sys.exit(1) self.__config_app = sys.argv[1] if os.path.isfile(self.__config_app): self.__settings = Settings(self.__config_app) else: print(os.path.realpath(self.__config_app)) sys.exit(1)
def connect(): if not MysqlServer.cnf: settings = Settings.get() if settings['db_use'] == 'master': MysqlServer.cnf = settings['mysqlserver_master'] elif settings['db_use'] == 'slave': MysqlServer.cnf = settings['mysqlserver_slave'] return torndb.Connection( host='%s:%s' % (MysqlServer.cnf['host'], MysqlServer.cnf['port']), database=MysqlServer.cnf['db'], user=MysqlServer.cnf['user'], password=MysqlServer.cnf['pwd'])
class Game: def __init__(self): # Settings self.settings = Settings() self.settings.load() self.screen = window(self.settings) self.running = True self.clock = pygame.time.Clock() self.fps = self.settings.fps self.dt = self.clock.tick(self.fps) / 1000 self.last_screen = [0, 0] self.fps_label = Text(self.screen, int(self.clock.get_fps()), [0, 0, 50, 50], font_size=35) def video_event(self, event): if event.type == pygame.VIDEORESIZE: if not self.settings.fullscreen: self.last_screen = [ self.screen.get_width(), self.screen.get_height() ] self.screen = pygame.display.set_mode((event.w, event.h), pygame.RESIZABLE) return True return False def update(self): self.fps_label = Text(self.screen, int(self.clock.get_fps()), [0, 0, 50, 50], font_size=35) def draw(self): self.screen.fill((0, 0, 0)) self.fps_label.draw()
def __init__(self): u""" Loads colorama for color output in shell, loads personal settings. """ Shell.initColorama() self.settings = Settings() itunesCollection = self.getITunes(pathXML=self.settings.BACKUP_LIBRARY, pathJSON=self.ITUNES_JSON) localItunesCollection = self.getITunes( pathXML=self.settings.LOCAL_LIBRARY, pathJSON=self.LOCALITUNES_JSON, force=True) #filesCollection = self.getCollection(pathFiles=self.settings.BACKUP, pathJSON=self.COLLECTION_JSON) self.compareCollection(localItunesCollection, itunesCollection)
def connect(): if not MysqlServer.cnf: settings = Settings.get() if settings['db_use'] == 'master': MysqlServer.cnf = settings['mysqlserver_master'] elif settings['db_use'] == 'slave': MysqlServer.cnf = settings['mysqlserver_slave'] return MySQLdb.connect(host=MysqlServer.cnf['host'], port=int(MysqlServer.cnf['port']), db=MysqlServer.cnf['db'], user=MysqlServer.cnf['user'], passwd=MysqlServer.cnf['pwd'], cursorclass=cursors.DictCursor, charset='utf8')
def __init__(self, screen, rect, health=100, name=None, save_entity=False): # Load settings self.settings = Settings() self.settings.load() self.screen = screen self.rect = rect # Save self.name = name self.save_entity = save_entity self.file_path = 'data/data.json' # Just incase if name is None and self.save_entity: print('Saved was set to true, but no name was passed.') self.save_entity = False # Health self.max_health = health self.health = self.max_health self.health_rect = [ int(self.rect[0] + self.rect[2] / 2 - int(self.rect[2] * 1.3) / 2), int(self.rect[1] - int(self.rect[3] / 8) * 3), int(self.rect[2] * 1.3), int(self.rect[3] / 8) ] self.health_color = (255, 0, 0) # Loadout # These if not none will need to be passed into the control script for entity self.weapon = None self.helmet = None self.chestplate = None self.boots = None
def set_sell_purchase_timespan(): settings = Settings() settings.start_purchase = datetime_to_string(timezone.now()) settings.end_purchase = datetime_to_string(timezone.now() + timedelta(1)) settings.start_sell = datetime_to_string(timezone.now()) settings.end_sell = datetime_to_string(timezone.now() + timedelta(1))
class Fennec(object): def __init__(self, files_list, root_path = None): if (root_path == None): root_path = path.abspath(path.join( path.abspath(path.dirname( path.abspath(inspect.getfile( inspect.currentframe())))), "..")) self.logger = Logger(root_path) self.settings = Settings(root_path) self.context = Context(self.settings) for filepath in files_list: self.context.load_path(filepath) def set_settings(self, name, value): self.settings.set(name, value) def set_configfile(self, path_config): # try importing from given path try: self.settings.read_file(path_config) return except IOError: pass # try importing in default config dir root_path = self.settings.get('root_path') try: self.settings.read_file(path.join( root_path, "settings", "config", path_config + '.py')) return except IOError: pass # try importing from current working directory in config dir curr_dir = path.abspath(os.getcwd()) try: self.settings.read_file(path.join( curr_dir, "config", path_config + '.py')) return except: self.logger.get_logger().error("Could not impot configuration file") raise def add_paths(self, paths): for path in paths: self.context.load_path(path) def audit(self): """ Launch code audit process """ self.context.audit() def clean(self): """ Cleans the logs, traces and temporary files (if there are some) """ log_path = os.path.join(self.settings.get('root_path'), "log", "*") traces_path = os.path.join(self.settings.get('root_path'), "trace", "*") to_remove = glob.glob(log_path) for node in to_remove: if node.endswith('.log'): os.remove(node) to_remove = glob.glob(traces_path) for node in to_remove: if node.endswith('.log'): os.remove(node) self.logger.get_logger().info("Finished cleaning.")