def test_should_initialize_properties(self): configuration = Configuration() configuration._get_file_content = MagicMock( return_value='{"name": "test_name", "password": "******"}') configuration.load("test") self.assertEqual("test_name", configuration.name) self.assertEqual("test_password", configuration.password)
def test_someone_should_be_home(self): configuration = Configuration() configuration.ip = ["123", "234"] handler = MotionDetectionHandler(configuration, None) handler._is_home = MagicMock(return_value=True) self.assertEqual(True, handler._is_anyone_home()) handler._is_home.assert_called_once_with("123")
def test_should_initialize_map_properties(self): configuration = Configuration() configuration._get_file_content = MagicMock( return_value='{"arr": {"name": "test_name", "name2": "test_name2"}}' ) configuration.load("test") self.assertEqual("test_name", configuration.arr["name"])
def test_should_call_tram_handler_unknown_param(self): configuration = Configuration() configuration.home_address = "home" configuration.work_address = {"sender": { "target": "work", "waypoint": "point"}} handler = TramHandler() handler.process = MagicMock(return_value="") command = TramCommand("fake") self.assertEqual("Unknown tram params: fake", command.process("sender"))
def __init__(self): self._wLog = WeatherLogger() self._wLog.logDebugMessage("initialize class system state") self._configuration = Configuration() self._configuration.getConfigurationFiles() self._systemConfig = self._configuration.getSystemConfig() self._serverConfig = self._configuration.getServerConfig() self.initHandler()
def get_telegram_service(): configuration_telegram = Configuration() configuration_telegram.load(ConfigurationEnum.Telegram) telegram_service = TelegramService(configuration_telegram) telegram_service.send_video = MagicMock(return_value=None) telegram_service.send_photo = MagicMock(return_value=None) telegram_service.send_text = MagicMock(return_value=None) return telegram_service
def test_should_process(self): telegram_service = TestUtil.get_telegram_service() telegram_service.check_updates(TestUtil.get_telegram_message("quotes")) mock_call = telegram_service.send_text.mock_calls response = str(mock_call[0][1]) configuration = Configuration() configuration.load(ConfigurationEnum.Quote) for quote in configuration.quotes: self.assertTrue(quote in response)
def test_should_load_file(self): configuration = Configuration("testConfig.json") expected_json = json.loads('{"clientId": "espClientTest",' ' "wifiSsid" : "wifiTest", ' '"wifiSecret" : "secreTtest"}') json_data = configuration.read_json() self.assertEquals(json_data, expected_json)
def main(): config = Configuration() config.print_detailed_config_used_for_training() dataset = FullDataset(config.training_data_folder, config, training=True) dataset.load() dataset = Representation.convert_dataset_to_baseline_representation( config, dataset) checker = ConfigChecker(config, dataset, 'snn', training=True) checker.pre_init_checks() snn = initialise_snn(config, dataset, True) snn.print_detailed_model_info() if config.print_model: tf.keras.utils.plot_model(snn.encoder.model, to_file='model.png', show_shapes=True, expand_nested=True) checker.post_init_checks(snn) start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S") print('---------------------------------------------') print('Training:') print('---------------------------------------------') print() optimizer = SNNOptimizer(snn, dataset, config) optimizer.optimize() print() print('---------------------------------------------') print('Inference:') print('---------------------------------------------') print() change_model(config, start_time_string) if config.case_base_for_inference: dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False) else: dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False) dataset.load() dataset = Representation.convert_dataset_to_baseline_representation( config, dataset) snn = initialise_snn(config, dataset, False) inference = Inference(config, snn, dataset) inference.infer_test_dataset()
def test_should_call_tram_handler(self): configuration = Configuration() configuration.home_address = "src" configuration.work_address = {"sender": { "target": "dest", "waypoint": "point"}} handler = TramHandler() handler.process = MagicMock(return_value="from src to dest") command = TramCommand(None) command._get_tram_configuration = MagicMock(return_value=configuration) command._get_tram_handler = MagicMock(return_value=handler) self.assertEqual("from src to dest", command.process("sender"))
def test_should_initialize_telegram_properties(self): configuration = Configuration() configuration.load(ConfigurationEnum.Telegram) self.assertIsNotNone(configuration.token) self.assertIsNotNone(configuration.url) self.assertIsNotNone(configuration.interval) self.assertIsNotNone(configuration.allowed_access) self.assertIsNotNone(configuration.pi_name) self.assertIsNotNone(configuration.slaves) self.assertIsNotNone(configuration.is_master)
def test_should_not_update_presence_time_if_too_soon(self): configuration = Configuration() configuration.ip = ["123", "234"] handler = MotionDetectionHandler(configuration, None) last_presence_time = datetime.now() - timedelta(minutes=5) handler._is_anyone_home = MagicMock(return_value=True) handler.last_presence_time = last_presence_time handler.process(1) self.assertEqual(handler.last_presence_time, last_presence_time) self.assertFalse(handler._is_anyone_home.called)
def test_should_update_presence_time_if_someone_home(self): configuration = Configuration() configuration.ip = ["123", "234"] handler = MotionDetectionHandler(configuration, None) handler._is_anyone_home = MagicMock(return_value=True) last_presence_time = datetime.now() - timedelta(days=1) handler.last_presence_time = last_presence_time handler.process(1) handler._is_anyone_home.assert_called_once_with() self.assertTrue(handler.last_presence_time > last_presence_time)
def startObservation(self, callback): configuration = Configuration() configuration.load(ConfigurationEnum.Pir) GPIO.setmode(GPIO.BCM) GPIO.setup(configuration.pir_pin, GPIO.IN) GPIO.add_event_detect(configuration.pir_pin, GPIO.RISING, callback, bouncetime=300) LoggingService().info("Start observation.")
def test_should_not_allow_unauthorized(self): configuration = Configuration() configuration.name = "name" configuration.password = "******" configuration.is_master = True configuration.allowed_access = [111, 2222] telegram_service = TelegramService(configuration) telegram_service.send_text = MagicMock(return_value=None) msg = [{"update_id":32, "message":{"message_id":66,"from":{"id":333,"first_name":"34"},"chat":{"id":333,"first_name":"33"},"text":"status"}}] telegram_service.check_updates(msg) telegram_service.send_text.assert_called_once_with(333, "Unauthorized access from 333")
def test_should_process_command(self): configuration = Configuration() configuration.name = "name" configuration.password = "******" configuration.is_master = True configuration.allowed_access = [111, 222] telegram_service = TelegramService(configuration) telegram_service.send_text = MagicMock(return_value=None) msg = [{"update_id":32, "message":{"message_id":66,"from":{"id":111,"first_name":"34"},"chat":{"id":111,"first_name":"33"},"text":"status"}}] telegram_service.check_updates(msg) self.assertEqual(1, telegram_service.send_text.call_count)
def test_should_process_when_nobody_home(self): configuration = Configuration() configuration.ip = ["192.168.0.0"] telegram_service = TestUtil.get_telegram_service() telegram_service.send_to_all = MagicMock() handler = MotionDetectionHandler(configuration, telegram_service) handler._send_video = MagicMock() handler.last_presence_time = datetime.now() - timedelta(days=1) handler.process(1) handler._send_video.assert_called_once_with() telegram_service.send_to_all.assert_called_once_with({'message_text': 'Motion on channel 1'})
def test_should_call_tram_handler_default(self): configuration = Configuration() configuration.home_address = "home" configuration.work_address = {"sender": { "target": "work", "waypoint": "point"}} handler = TramHandler() handler.process = MagicMock(return_value="") command = TramCommand(None) command._get_tram_configuration = MagicMock(return_value=configuration) command._get_tram_handler = MagicMock(return_value=handler) command.process("sender") handler.process.assert_called_once_with("home", "work", "point")
def test_should_process_when_someone_home(self): configuration = Configuration() configuration.ip = ["173.194.116.88"] telegram_service = TestUtil.get_telegram_service() telegram_service.send_to_all = MagicMock() handler = MotionDetectionHandler(configuration, telegram_service) handler._send_video = MagicMock() last_presence_time = datetime.now() - timedelta(days=1) handler.last_presence_time = last_presence_time handler.process(1) self.assertTrue(handler.last_presence_time > last_presence_time) self.assertFalse(handler._send_video.called)
def test_should_send_message(self): configuration = Configuration() configuration.ip = ["123", "234"] handler = MotionDetectionHandler(configuration, None) handler._is_anyone_home = MagicMock(return_value=False) handler._send_video = MagicMock() handler.telegram_service = MagicMock() handler.last_presence_time = datetime.now() - timedelta(days=1) handler.process(10) handler.telegram_service.send_to_all.assert_called_once_with( {'message_text': 'Motion on channel 10'}) handler._send_video.assert_called_once_with()
def testConfiguration(self): conf = Configuration() conf.populationSize = 40 conf.crossoverProbability = 0.5 conf.mutationProbability = 0.2 conf.maxTimeInSeconds = 10 conf.maxGenerationNumber = 50 conf.maxMutationEvents = 600 conf.maxImprovementsNumber = 15 return conf
def __init__(self): configuration = Configuration() self.configParser = configuration.getConfigParser() # create an engine self.engine = create_engine('postgresql://{}:{}@{}:{}/{}'.format( self.configParser.get('POSTGRESQL', 'username'), self.configParser.get('POSTGRESQL', 'password'), self.configParser.get('POSTGRESQL', 'host'), self.configParser.get('POSTGRESQL', 'port'), self.configParser.get('POSTGRESQL', 'dbname'))) # create a configured "Session" class self.Session = sessionmaker(bind=self.engine) # create a Session self.session = self.Session()
def main(): # suppress debugging messages of TensorFlow os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' config = Configuration() config.print_detailed_config_used_for_training() dataset = FullDataset(config.training_data_folder, config, training=True) dataset.load() checker = ConfigChecker(config, dataset, 'snn', training=True) checker.pre_init_checks() snn = initialise_snn(config, dataset, True) snn.print_detailed_model_info() checker.post_init_checks(snn) start_time_string = datetime.now().strftime("%m-%d_%H-%M-%S") print('---------------------------------------------') print('Training:') print('---------------------------------------------') print() optimizer = SNNOptimizer(snn, dataset, config) optimizer.optimize() print() print('---------------------------------------------') print('Inference:') print('---------------------------------------------') print() change_model(config, start_time_string) if config.case_base_for_inference: dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False) else: dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False) dataset.load() snn = initialise_snn(config, dataset, False) inference = Inference(config, snn, dataset) inference.infer_test_dataset()
def test_should_load_wifi_parameters(self): configuration = Configuration("testConfig.json") wifi_configuration = configuration.wifi self.assertEquals(wifi_configuration.ssid, "wifiTest") self.assertEquals(wifi_configuration.secret, "secreTtest")
def main(): config = Configuration() if config.case_base_for_inference: dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False) else: dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False) dataset.load() # select which part of the test dataset to test start_index = 0 # dataset.num_test_instances end_index = dataset.num_test_instances # dataset.num_test_instances # Output interval of how many examples have been compared so far. < 0 for no output temp_output_interval = -1 use_relevant_only = True implemented_algorithms = ['dtw', 'dtw_weighting_nbr_features', 'feature_based'] algorithm_used = implemented_algorithms[0] distance_to_sim_methods = ['1/(1+d)', 'div_max', 'min_max_scaling'] distance_to_sim_method = distance_to_sim_methods[0] relevant_type = 'Individual' if config.individual_relevant_feature_selection else 'Group based' print('Algorithm used:', algorithm_used) print('Used relevant only:', use_relevant_only) print('Type of feature selection:', relevant_type) print('Start index:', start_index) print('End index:', end_index) print('Number of parallel threads:', config.max_parallel_cores) print('Case Based used for inference:', config.case_base_for_inference) print() execute_baseline_test(dataset, start_index, end_index, config.max_parallel_cores, algorithm_used, config.k_of_knn, temp_output_interval, use_relevant_only, distance_to_sim_method)
def main(): config = Configuration() if config.case_base_for_inference: dataset: FullDataset = FullDataset(config.case_base_folder, config, training=False) else: dataset: FullDataset = FullDataset(config.training_data_folder, config, training=False) dataset.load() dataset = Representation.convert_dataset_to_baseline_representation( config, dataset) checker = ConfigChecker(config, dataset, 'snn', training=False) checker.pre_init_checks() architecture = initialise_snn(config, dataset, False) checker.post_init_checks(architecture) inference = Inference(config, architecture, dataset) if config.print_model: tf.keras.utils.plot_model(architecture.encoder.model, to_file='model.png', show_shapes=True, expand_nested=True) print('Ensure right model file is used:') print(config.directory_model_to_use, '\n') inference.infer_test_dataset()
def main(): config = Configuration(9) topic_list = config.topic_list topic_to_file = { 'txt15': 'txt15.txt', 'txt16': 'txt16.txt', 'txt17': 'txt17.txt', 'txt18': 'txt18.txt', 'txt19': 'txt19.txt', 'adxl1': 'TXT15_m1_acc.txt', 'adxl0': 'TXT15_o8Compressor_acc.txt', 'adxl3': 'TXT16_m3_acc.txt', 'adxl2': 'TXT18_m1_acc.txt', 'pressureSensors': 'pressureSensors.txt' } timer_start = time.perf_counter() for i in range(len(topic_list)): sim = ProducerSimulator(name='t' + str(i), topic_name=topic_list[i], file_name=topic_to_file[topic_list[i]], config=config) sim.start() timer_end = time.perf_counter() print(timer_end - timer_start)
def main(): # suppress debugging messages of tensorflow tf.logging.set_verbosity(tf.logging.ERROR) os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' config = Configuration() model_type = config.architecture_type model_file = config.model_file dataset_path = config.preprocessed_folder choice = config.inference_type # todo remove # import testing.only_failure # dataset_path = testing.only_failure.temp_dir if choice == 'test': start_pct = 0.0 chunk_pct = 1.0 elif choice == 'pairwise': num_test_batches = 1 # Change when needed # prepare inference with given parameters ie = Inference(model_type=model_type, model_file=model_file, dataset_path=dataset_path) print('\nEnsure right model file is used:') print(config.model_file, '\n') # call the corresponding inference method if choice == 'test': ie.infer_dataset(start_pct, chunk_pct) elif choice == 'pairwise': ie.pairwise_test_accuracy(num_test_batches)
def main(): try: # suppress debugging messages of TensorFlow os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # os.environ['report_tensor_allocations_upon_oom'] = '1' config = Configuration() dataset = CBSDataset(config.training_data_folder, config, training=True) dataset.load() checker = ConfigChecker(config, dataset, 'cbs', training=True) checker.pre_init_checks() print('Initializing case based similarity measure ...\n') cbs = CBS(config, True, dataset) checker.post_init_checks(cbs) print('\nTraining:\n') optimizer = CBSOptimizer(cbs, dataset, config) optimizer.optimize() except KeyboardInterrupt: try: cbs.kill_threads() except: pass
def main(): # change options who a pandas dataframe is printed to console, the full dataframe should be printed pd.set_option('display.max_rows', 500) pd.set_option('display.max_columns', 500) pd.set_option('display.width', 1000) # enable plotting for each dataset plot = False config = Configuration() datasets_info = [] # generate dataset information based on folder name for i in range(len(config.datasets)): file_name = config.datasets[i][0].split('/')[-2] file_name_parts = file_name.split('_') if file_name_parts[0] in ['txt15', 'txt16']: info = (i, file_name_parts[0], file_name_parts[1], file_name_parts[2], file_name) datasets_info.append(info) dfs = [] for info in datasets_info: # extract the cases from a single dataset into a dataframe dfs.append(extract_cases(info, plot)) # export to a single text file export_cases_all(dfs, config)
def main(): try: # suppress debugging messages of TensorFlow os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' config = Configuration() if config.case_base_for_inference: dataset: CBSDataset = CBSDataset(config.case_base_folder, config, training=False) else: dataset: CBSDataset = CBSDataset(config.training_data_folder, config, training=False) dataset.load() checker = ConfigChecker(config, dataset, 'cbs', training=False) checker.pre_init_checks() cbs = CBS(config, False, dataset) inference = Inference(config, cbs, dataset) checker.post_init_checks(cbs) print('Ensure right model file is used:') print(config.directory_model_to_use, '\n') inference.infer_test_dataset() cbs.kill_threads() except KeyboardInterrupt: try: cbs.kill_threads() except: pass
def test_should_load_mqtt_parameters(self): configuration = Configuration("../config.json") mqtt_configuration = configuration.mqtt self.assertEquals(mqtt_configuration.topic_sub, "myfirst/test") self.assertEquals(mqtt_configuration.topic_pub, "myfirst/test") self.assertEquals(mqtt_configuration.mqtt_server, "10.76.124.45")
def load(): config = Configuration() relevant_features = config.case_to_individual_features for key in relevant_features: relevant_features[key] = sorted(relevant_features[key]) return sorted(relevant_features.keys()), relevant_features
def main(): config = Configuration(14) with open(config.topicPressureSensorsFile) as f: content = json.load(f) selection = 2 if selection == 0: post = '15' df_sensor_data = import_single_pressure_sensor(content, 'Sorter', post) elif selection == 1: post = '17' df_sensor_data = import_single_pressure_sensor(content, 'Oven', post) elif selection == 2: post = '18' df_sensor_data = import_single_pressure_sensor(content, 'VSG', post) # change format of timestamp, set it as index and reduce the time interval df_sensor_data['timestamp'] = pd.to_datetime(df_sensor_data['timestamp']) df_sensor_data = df_sensor_data.set_index(df_sensor_data['timestamp']) df_sensor_data.query(config.query, inplace=True) df_sensor_data.drop('timestamp', 1, inplace=True) df_sensor_data.drop('tC_' + post, 1, inplace=True) # get timestamps of labels # df_red = df_sensor_data.loc[df_sensor_data['txt16_label'] == 'TXT16_i4_failuremode1'] # print(df_red) # add timestamps of cases to display in the plot if selection == 2: timestamps = [ '2019-06-08 11:42:00.080158', '2019-06-08 11:49:00.082672', # '2019-06-08 11:50:45.008662', '2019-06-08 11:56:19.046031', '2019-06-08 11:56:5.046031', '2019-06-08 11:58:55.925578', ] elif selection == 1: timestamps = [ # '2019-06-08 11:59:58.004812', '2019-06-08 12:01:00.974244', no error visible irl and in data '2019-06-08 12:13:07.064066', '2019-06-08 12:13:38.012230', '2019-06-08 12:16:57.061182', '2019-06-08 12:18:36.992235', '2019-06-08 12:20:15.060076', '2019-06-08 12:21:13.975116' ] elif selection == 0: timestamps = [] timestamps = transform(timestamps) plot_export_txt(df_sensor_data, 'pressure failure', config, timestamps)
def test_should_initialize_tram_properties(self): configuration = Configuration() configuration.load(ConfigurationEnum.Tram) self.assertIsNotNone(configuration.home_address) self.assertIsNotNone(configuration.work_address)
def test_should_initialize_properties(self): configuration = Configuration() configuration._get_file_content = MagicMock(return_value='{"name": "test_name", "password": "******"}') configuration.load("test") self.assertEqual("test_name", configuration.name) self.assertEqual("test_password", configuration.password)
def test_should_initialize_map_properties(self): configuration = Configuration() configuration._get_file_content = MagicMock(return_value='{"arr": {"name": "test_name", "name2": "test_name2"}}') configuration.load("test") self.assertEqual("test_name", configuration.arr["name"])
def test_should_initialize_quote_properties(self): configuration = Configuration() configuration.load(ConfigurationEnum.Quote) self.assertIsNotNone(configuration.quotes)
from configuration.Configuration import Configuration from configuration.ConfigurationEnum import ConfigurationEnum from domain_services.logging_service.LoggingService import LoggingService from domain_services.telegram_service.TelegramService import TelegramService from domain_services.motion_detection_service.MotionDetectionService import MotionDetectionService from handlers.MotionDetectionHandler import MotionDetectionHandler import pexpect if __name__ == '__main__': configuration_telegram = Configuration() configuration_telegram.load(ConfigurationEnum.Telegram) LoggingService.info("Start telegram service") telegram_service = TelegramService(configuration_telegram) configuration_wifi = Configuration() configuration_wifi.load(ConfigurationEnum.Ip) motion_detection_handler = MotionDetectionHandler(configuration_wifi, telegram_service) motion_detection_service = MotionDetectionService() motion_detection_service.startObservation(motion_detection_handler.process) telegram_service.connect()
def _get_tram_configuration(self): configuration = Configuration() configuration.load(ConfigurationEnum.Tram) return configuration
def _get_temp_configuration(self): configuration = Configuration() configuration.load(ConfigurationEnum.Temp) return configuration
def _get_configuration(self): configuration = Configuration() configuration.load(ConfigurationEnum.Quote) return configuration
def get_telegram_authorized_user(): configuration_telegram = Configuration() configuration_telegram.load(ConfigurationEnum.Telegram) return configuration_telegram.allowed_access[0]
def test_should_initialize_wifi_properties(self): configuration = Configuration() configuration.load(ConfigurationEnum.Ip) self.assertIsNotNone(configuration.ip)
def test_should_initialize_gpio_properties(self): configuration = Configuration() configuration.load(ConfigurationEnum.Pir) self.assertIsNotNone(configuration.pir_pin)