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.")
