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