def test_equal(self): m1 = Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time) m2 = Monitor(self.url + "diff", self.http_status, self.response_time, self.page_content, self.date_time) self.assertNotEqual(m1, m2) self.assertEqual(m1, m1) print(m1 == 1) self.assertNotEqual(m1, 1)
def main(name, address, client, proxy_client, server, proxy_server, output_dir, log_dir, tasks, size, timeout, stun_test, ipfs, dat, connect): assert (ipfs or dat) and not (ipfs and dat), "Please specify the IPFS or Dat flag" if client or proxy_client: if ipfs: cls = IPFSClientSession else: cls = DatClientSession if proxy_client: proxy_client = (address, proxy_client) logic = cls(name, address, output_dir, log_dir, int(tasks), int(size), proxy=proxy_client, connect=connect) elif server or proxy_server: if ipfs: cls = IPFSServerSession else: cls = DatServerSession if proxy_server: proxy_server = (address, None) logic = cls(name, address, output_dir, log_dir, int(size), proxy=proxy_server, connect=connect) else: raise RuntimeError( "Neither (proxy) client or (proxy) server mode specified") if stun_test: perform_stun_test() session = Monitor(logic, timeout=int(timeout)) session.start()
def main(): # Ensure Python version if sys.version_info < (3, 0): print('Please use python 3 to run this program') # Get arguments from execution parser = ArgumentParser() parser.add_argument("-t", "--target", required=True, help="Target website to monitor") parser.add_argument("-c", "--config", required=True, help="Path to config file") parser.add_argument("-i", "--interval", required=False, default=1, help="Time interval in seconds to polling data") args = parser.parse_args() # Read configuration file with open(args.config) as fh: config_file = json.load(fh) kafka_config = config_file.get("kafka", {}) # Initialise kafka producer producer = KafkaProducer( bootstrap_servers=kafka_config["kafka_url"], security_protocol="SSL", ssl_cafile=kafka_config['ssl_ca_file'], ssl_certfile=kafka_config['ssl_access_certificate_file'], ssl_keyfile=kafka_config['ssl_access_key_file'], ) while True: monitor = Monitor(args.target) monitor.fetch() # Format monitoring data into JSON message = json.dumps(monitor.__dict__, indent=4) print("Sending: ", format(message)) producer.send("monitoring", message.encode("utf-8")) # Force sending of all messages producer.flush() zzz = float(args.interval) print("sleeping for {} seconds Zzz...".format(zzz)) time.sleep(zzz)
def main(): # account like : 0x3121213232 # tele like: '13012345678' monitor = Monitor('your-account') sender = SMSSender('your-api-key') tele = 'your-tele' while (1): offline_workders = monitor.get_offline_workers() if offline_workders: print('worker {0} are offline'.format(offline_workders)) sender.send_warning(tele, offline_workders) else: print('no worker is offline') sleep(30)
def test_to_string(self): expected = "<class 'monitor.monitor.Monitor'>: {'url': 'https://duckduckgo.com', 'http_status': 200, 'response_time': 0.100604, 'page_content': 'content', 'date_time': 1592379760.808488}" actual = str( Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time)) self.assertEqual(expected, actual)
def test_decode_json(self): expected = Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time) actual = self.monitor.decode_json(json.loads(self.sample)) print("actual -", actual) print("expected", expected) self.assertEqual(expected, actual)
def __init__(self, federated_clusters): redis_host = sys.argv[1] redis_port = sys.argv[2] self.redis = redis.Redis(host=redis_host, port=redis_port) self._monitors = [] for cluster in federated_clusters: addr = CONFIG.get(cluster, "address") logging.info("Updated configuration for cluster: %s", cluster) self._monitors.append(Monitor(cluster, addr))
def test_new_monitor_device_not_found(self): config = ConfigParser() config['system'] = {'key': 'testkey', 'secret': 'testsecret'} config['messaging'] = {'channel': '/test/channel'} with open(TEST_CONFIG, 'w') as f: config.write(f) with mock.patch('clearblade.ClearBladeCore.System') as m: with self.assertRaises(KeyError): monitor = Monitor(TEST_CONFIG)
def test_new_monitor_happy_case(self): config = ConfigParser() config['system'] = {'key': 'testkey', 'secret': 'testsecret'} config['device'] = {'name': 'testname', 'active_key': 'testactivekey'} config['messaging'] = {'channel': '/test/channel'} with open(TEST_CONFIG, 'w') as f: config.write(f) with mock.patch('clearblade.ClearBladeCore.System.Device') as m: monitor = Monitor(TEST_CONFIG) self.assertEqual('/test/channel', monitor.channel)
def test_new_monitor_messaging_not_found(self): config = ConfigParser() config['system'] = {'key': 'testkey', 'secret': 'testsecret'} config['device'] = {'name': 'testname', 'active_key': 'testactivekey'} with open(TEST_CONFIG, 'w') as f: config.write(f) with mock.patch('clearblade.ClearBladeCore.System.Device') as m: m.return_value = None with self.assertRaises(KeyError): monitor = Monitor(TEST_CONFIG)
def run_all(): _name_ = 'main' print('\n【{}】【{}】 新一轮调度开始 at version {}'.format(datetime.now(), _name_, flags.version)) config_dict = None try: config_dict = read_db_config() print('【{}】【{}】 读取 config.text 文件成功'.format(datetime.now(), _name_)) flags.version = 0 flags.server_time_interval = config_dict['schedule_timestep_seconds'] except Exception as e: print('【{}】【{}】 读取 config.txt 文件失败,原因:{}'.format( datetime.now(), _name_, repr(e))) flags.version = 1 monitor = Monitor(config_dict) if flags.version == 0: monitor.run() server = Server(config_dict) server.run_real() a = 1
def auto_job(): linux_dict = get_linux_config() content_list = [] """ [(10.10.111.1,cd $(locate taskmngdomain1/nohuplogs) ; tail -50 *log*`date +%F`*), (10.10.111.2,cd $(locate taskmngdomain2/nohuplogs) ; tail -50 *log*`date +%F`*)]""" cmd_list = gol.get_value('cmd_list') for ip in linux_dict: linux_info = linux_dict[ip].split( ',') # 根据ip获取user和pwd,通过逗号分隔成list(linux_info--> [user,pwd]) user = linux_info[0] pwd = linux_info[1] monitor = Monitor(ip, user, pwd) # cmd的获取,添加根据ini不同ip实现动态对应linux指令 for cmd_tuple in cmd_list: if cmd_tuple[0] == ip: cmd = cmd_tuple[1] # 将指令赋予cmd break # 若找到了,则不浪费循环资源直接跳出 content = f'当前服务器ip:{ip},日志内容:\n' + monitor.link_server(cmd) + '\n\n' content_list.append(content) sendMail = SendMail() sendMail.send_mails(''.join(content_list)) sendMail.mail_close() #关闭连接
def startCalibration(self, sensorName, port): """ Starts calibration and instantiates the EMT system :param sensorName: the uncalibrated sensor :param port: the port the uncalibrated sensor is connected to """ if self.mode == MODE_IDLE: try: config = guiutils.import_default_config_settings() primaryChannels = config['system']['primary_channels'] sensor = utils.get_sensor(sensorName) sensor.channel = utils.get_active_channel(sensor.dof, port, primaryChannels) calibration = EMCalibration(sensor, config) qtScheduler = QtScheduler(QtCore) newScheduler = NewThreadScheduler() self.systemMonitor = Monitor(calibration.anser) self.subscriptions.append(calibration.anser.sampleNotifications.sample(500, scheduler=newScheduler)\ .subscribe(self.systemMonitor.run_system_test)) self.subscriptions.append(self.systemMonitor.systemNotifications.subscribe_on(scheduler=qtScheduler)\ .subscribe(self.SYS_EVENT_SYSTEM_STATUS_NOTIFICATION.emit)) #remove this for i in range(3): calibration.anser.sample_update() self.calibrationThread = CalibrationThread(calibration, self.SYS_EVENT_POINT_CAPTURED, self.SYS_EVENT_READY_TO_CALIBRATE, self.SYS_EVENT_CALIBRATION_COMPLETED) self.calibrationThread.start() self.systemStatus = True self.SYS_EVENT_SYSTEM_STATUS.emit(self.systemStatus) self.SYS_EVENT_MODE_CALIBRATION.emit() self.SYS_EVENT_POINT_CAPTURED.emit(1) self.mode = MODE_CALIBRATING self.SYS_EVENT_MODE_CHANGED.emit(self.mode) logging.info('Started Calibration') except Exception as e: logging.info('Device cannot be accessed. Possible causes: ' '\n - Computer is not connected to DAQ port ' '\n - After plugging device into the USB Port, ' 'wait a few moments to let the driver install' '\n - Ensure device specified is correct. ' '\n (Go to -> Developer Tab, in the configuration file under \'system\' change the \'device_name\' to your DevX indentifier) \n') print(str(e)) elif self.mode == MODE_CALIBRATING: self.stopCalibration() else: logging.info('System is currently in use. Please stop tracking to continue')
def main(): log.info('===============================>>>') log.info('启动服务器...') from database.mysqlConnPool import MysqlConn mysqlConner = MysqlConn(readconf('config.conf', 'mysql')) if not mysqlConner.testConnection(): sys.exit(0) from collection.collection import Collection from communication.innerCommunication import InnerCommunication from monitor.monitor import Monitor innerCommun = InnerCommunication(readconf('config.conf','web-server')) innerCommun.createSingleProc() monitor = Monitor(readconf('config.conf','collection-server')) monitor.createProc() collection = Collection(readconf('config.conf','collection-server')) collection.createThreads()
def __init__(self, model: nn.Module, criterion: nn.Module, dataset_name: str, accuracy_measure: Accuracy = None, env_suffix='', checkpoint_dir=CHECKPOINTS_DIR): if torch.cuda.is_available(): model = model.cuda() self.model = model self.criterion = criterion self.dataset_name = dataset_name self.checkpoint_dir = Path(checkpoint_dir) self.train_loader = get_data_loader(dataset_name, train=True) self.timer = timer self.timer.init(batches_in_epoch=len(self.train_loader)) self.env_name = f"{time.strftime('%Y.%m.%d')} {self.model.__class__.__name__}: " \ f"{self.dataset_name} {self.__class__.__name__} {self.criterion.__class__.__name__}" if env_suffix: self.env_name = self.env_name + f' {env_suffix}' if accuracy_measure is None: if isinstance(self.criterion, PairLoss): accuracy_measure = AccuracyEmbedding() else: # cross entropy loss accuracy_measure = AccuracyArgmax() self.accuracy_measure = accuracy_measure self.monitor = Monitor(test_loader=get_data_loader(self.dataset_name, train=False), accuracy_measure=self.accuracy_measure) for name, layer in find_named_layers(self.model, layer_class=self.watch_modules): self.monitor.register_layer(layer, prefix=name) images, labels = next(iter(self.train_loader)) self.mask_trainer = MaskTrainer(accuracy_measure=self.accuracy_measure, image_shape=images[0].shape)
def monitor_factory(config_file): with open(config_file) as file_handle: configs = json.loads(file_handle.read()) monitors = [] for monitor_config in configs: validate_config(monitor_config) metrics = [] for metric_config in monitor_config["metrics"]: metrics.append(metric_factory(metric_config)) sinks = [] for sink_config in monitor_config["sinks"]: sinks.append(sink_factory(sink_config)) monitors.append(Monitor(metrics, sinks)) return monitors
def test_monitorSizeMod(qtbot): ''' Test the start of the PCV Mode, and then in PSV Mode ''' assert qt_api.QApplication.instance() is not None esp32 = FakeESP32Serial(config) qtbot.addWidget(esp32) window = MainWindow(config, esp32) qtbot.addWidget(window) monitor = Monitor("Insp. Press.", config) qtbot.addWidget(monitor) assert monitor.configname == "Insp. Press." monitor.handle_resize(None) monitor.highlight() value = monitor.value monitor.update_value(10) assert monitor.value == 10 monitor.value = value
def train_mask(): """ Train explainable mask for an image from ImageNet, using pretrained model. """ model = torchvision.models.vgg19(pretrained=True) model.eval() for param in model.parameters(): param.requires_grad_(False) normalize = torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = torchvision.transforms.Compose([ torchvision.transforms.Resize(size=(224, 224)), torchvision.transforms.ToTensor(), normalize ]) accuracy_measure = AccuracyArgmax() monitor = Monitor(test_loader=None, accuracy_measure=accuracy_measure) monitor.open(env_name='mask') monitor.normalize_inverse = NormalizeInverse(mean=normalize.mean, std=normalize.std) image = Image.open(IMAGES_DIR / "flute.jpg") image = transform(image) mask_trainer = MaskTrainer(accuracy_measure=accuracy_measure, image_shape=image.shape, show_progress=True) monitor.log(repr(mask_trainer)) if torch.cuda.is_available(): model = model.cuda() image = image.cuda() outputs = model(image.unsqueeze(dim=0)) proba = accuracy_measure.predict_proba(outputs) proba_max, label_true = proba[0].max(dim=0) print(f"True label: {label_true} (confidence {proba_max: .5f})") monitor.plot_mask(model=model, mask_trainer=mask_trainer, image=image, label=label_true)
def experiment(args): """ Note: - data type is np.float16 """ paths = load_json(args.paths_config) for k, v in paths.items(): if "PYTHONPATH" in k: sys.path.insert(0, v) from monitor.monitor import Monitor from repartition_experiments.scripts_exp.exp_utils import create_empty_dir, verify_results from repartition_experiments.algorithms.baseline_algorithm import baseline_rechunk from repartition_experiments.algorithms.keep_algorithm import keep_algorithm, get_input_aggregate from repartition_experiments.algorithms.utils import get_file_manager from repartition_experiments.algorithms.clustered_reads import clustered_reads # setting paths = load_json(args.paths_config) cases = load_json(args.cases_config) bpv = 2 indir_path, outdir_path = os.path.join(paths["ssd_path"], 'indir'), os.path.join( paths["ssd_path"], 'outdir') # creating empty output directories create_empty_dir(outdir_path) if args.distributed: print(f"Distributed mode -> creating the output directories") for i in range(6): dirpath = '/disk' + str(i) + '/gtimothee' create_empty_dir(os.path.join(dirpath, 'output')) fm = get_file_manager(args.file_format) if args.overwrite: fm.remove_all(paths["ssd_path"]) # transform cases into tuples + perform sanity check case = cases[args.case_name] for run in case: R, O, I, B, volumestokeep = tuple(run["R"]), tuple(run["O"]), tuple( run["I"]), tuple(run["B"]), run["volumestokeep"] if args.case_name.split('_')[0] == "case 1": lambd = get_input_aggregate(O, I) B, volumestokeep = (lambd[0], lambd[1], lambd[2]), list(range(1, 8)) run["volumestokeep"] = volumestokeep run["R"] = R run["O"] = O run["I"] = I run["B"] = B for shape_to_test in [O, I, B]: for dim in range(3): try: assert R[dim] % shape_to_test[dim] == 0 except Exception as e: print(R, shape_to_test) print(e) random.shuffle(case) results = list() R_prev, I_prev = (0, 0, 0), (0, 0, 0) for run in case: R, O, I, B, volumestokeep = run["R"], run["O"], run["I"], run[ "B"], run["volumestokeep"] ref = run["ref"] print( f'Case being processed: (ref: {ref}) {R}, {I}, {O}, {B}, {volumestokeep}' ) filename = f'{R[0]}_{R[1]}_{R[2]}_original.hdf5' origarr_filepath = os.path.join(paths["ssd_path"], filename) # resplit print("processing...") flush_cache() print(f"cache flushed") if args.model == "baseline": _monitor = Monitor(enable_print=False, enable_log=False, save_data=True) _monitor.disable_clearconsole() _monitor.set_delay(15) _monitor.start() t = time.time() tread, twrite, seeks_data = baseline_rechunk( indir_path, outdir_path, O, I, R, args.file_format, args.addition, args.distributed) t = time.time() - t _monitor.stop() piles = _monitor.get_mem_piles() max_voxels = 0 print(f"Processing time: {t}") print(f"Read time: {tread}") print(f"Write time: {twrite}") tpp = 0 voxel_tracker = None elif args.model == "keep": print(f"Running keep...") t = time.time() tpp, tread, twrite, seeks_data, voxel_tracker, piles = keep_algorithm( R, O, I, B, volumestokeep, args.file_format, outdir_path, indir_path, args.addition, args.distributed) t = time.time() - t - tpp max_voxels = voxel_tracker.get_max() print(f"Processing time: {t}") print(f"Read time: {tread}") print(f"Write time: {twrite}") elif args.model == "clustered": tpp = 0 m = args.clustered_mem * 1000000000 # one GIG _monitor = Monitor(enable_print=False, enable_log=False, save_data=True) _monitor.disable_clearconsole() _monitor.set_delay(15) _monitor.start() t = time.time() tread, twrite, seeks_data = clustered_reads( outdir_path, R, I, bpv, m, args.file_format, indir_path) t = time.time() - t - tpp _monitor.stop() piles = _monitor.get_mem_piles() voxel_tracker = None max_voxels = 0 print(f"Processing time: {t}") print(f"Read time: {tread}") print(f"Write time: {twrite}") else: raise ValueError("Bad model name") # verify and clean output print("verifying results....") if args.verify: split_merge = False if args.case_name == "case 3": split_merge = True success = verify_results(outdir_path, origarr_filepath, R, O, args.file_format, args.addition, split_merge) else: success = True print("successful run: ", success) results.append([ args.case_name, run["ref"], args.model, t, tpp, tread, twrite, seeks_data[0], seeks_data[1], seeks_data[2], seeks_data[3], max_voxels, success ]) create_empty_dir(outdir_path) R_prev, I_prev = R, I write_memory_pile(piles[0], piles[1], run["ref"], args) if voxel_tracker != None: write_voxel_history(voxel_tracker, run["ref"], args) return results
def setUp(self) -> None: self._monitor = Monitor("ws://test.com", "eth9", "user", "pass", True) self._monitor._update_output = Mock()
class MonitorTest(TestCase): def setUp(self) -> None: self._monitor = Monitor("ws://test.com", "eth9", "user", "pass", True) self._monitor._update_output = Mock() def test_single_frame_message(self): self._monitor.on_ws_message( self._read_sample("single_frame_message.txt")) self._monitor._update_output.assert_called_once() self._monitor._update_output.assert_called_with( 27296, 27832, "13.123.123.123") def test_single_frame_multi_message(self): self._monitor.on_ws_message( self._read_sample("single_frame_multi_message.txt")) self._monitor._update_output.assert_has_calls([ call(27296, 27832, "13.123.123.123"), call(27304, 27760, "13.123.123.123") ]) def test_multiple_frame_message(self): self._monitor.on_ws_message( self._read_sample("multi_frame_message_1.txt")) self._monitor.on_ws_message( self._read_sample("multi_frame_message_2.txt")) self._monitor._update_output.assert_called_once() self._monitor._update_output.assert_called_with( 1978872, 208192, "13.123.123.123") def test_multiple_frame_with_naked_header(self): self._monitor.on_ws_message( self._read_sample("multi_frame_message_naked_1.txt")) self._monitor.on_ws_message( self._read_sample("multi_frame_message_naked_2.txt")) self._monitor._update_output.assert_called_once() self._monitor._update_output.assert_called_with( 570848, 51624, "13.123.123.123") def test_human_rates(self): self.assertEqual(self._monitor._human_bps(123), "123 bps") self.assertEqual(self._monitor._human_bps(1250), "1.2 Kbps") self.assertEqual(self._monitor._human_bps(12500), "12.5 Kbps") self.assertEqual(self._monitor._human_bps(125000), "125.0 Kbps") self.assertEqual(self._monitor._human_bps(1250000), "1.2 Mbps") self.assertEqual(self._monitor._human_bps(12500000), "12.5 Mbps") self.assertEqual(self._monitor._human_bps(125000000), "125.0 Mbps") self.assertEqual(self._monitor._human_bps(1250000000), "1.2 Gbps") def _read_sample(self, file_name: str) -> str: abs_path = f"{dirname(abspath(__file__))}/{file_name}" with open(abs_path, "r") as file: return file.read()
class TestMonitor(TestCase): monitor = Monitor() def setUp(self): self.url = "https://duckduckgo.com" self.http_status = 200 self.response_time = 0.100604 self.page_content = "content" self.date_time = 1592379760.808488 self.sample = ''' {{ "url": "{}", "http_status": {}, "response_time": {}, "page_content": "{}", "date_time": {} }} '''.format(self.url, self.http_status, self.response_time, self.page_content, self.date_time) def test_equal(self): m1 = Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time) m2 = Monitor(self.url + "diff", self.http_status, self.response_time, self.page_content, self.date_time) self.assertNotEqual(m1, m2) self.assertEqual(m1, m1) print(m1 == 1) self.assertNotEqual(m1, 1) def test_to_string(self): expected = "<class 'monitor.monitor.Monitor'>: {'url': 'https://duckduckgo.com', 'http_status': 200, 'response_time': 0.100604, 'page_content': 'content', 'date_time': 1592379760.808488}" actual = str( Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time)) self.assertEqual(expected, actual) def test_class_representation(self): expected = "Monitor()" actual = repr(Monitor()) self.assertEqual(expected, actual) def test_decode_json(self): expected = Monitor(self.url, self.http_status, self.response_time, self.page_content, self.date_time) actual = self.monitor.decode_json(json.loads(self.sample)) print("actual -", actual) print("expected", expected) self.assertEqual(expected, actual) # We patch 'requests.get' with our own method. The mock object is passed in to our test case method. @mock.patch('requests.get', side_effect=mocked_requests_get) def test_fetch(self, mock_get): # Assert requests.get calls url = 'http://up.com' expected = Monitor(url, 200, 1, "html text", 1592379760.808488) actual = Monitor(url) actual.fetch() actual.date_time = 1592379760.808488 # setting of date_time is not part of the self.assertEqual(expected, actual) url = 'http://exceotion.com' expected = Monitor(url, None, None, None) actual = Monitor(url) actual.fetch() self.assertEqual(expected, actual)
def __init__(self, config, esp32, *args, **kwargs): #pylint: disable=too-many-statements """ Initializes the main window for the MVM GUI. See below for subfunction setup description. """ super(MainWindow, self).__init__(*args, **kwargs) uifile = os.path.join(os.path.dirname(os.path.realpath(__file__)), "mainwindow.ui") uic.loadUi(uifile, self) self.config = config self.esp32 = esp32 settings_file = SettingsFile(self.config["settings_file_path"]) self.user_settings = settings_file.load() ''' Start the alarm handler, which will check for ESP alarms ''' # Instantiate the critical alarm handler meant for severe communications and hardware error self.critical_alarm_handler = CriticalAlarmHandler(self, esp32) self.alarm_h = AlarmHandler( self.config, self.esp32, self.alarmbar, self.critical_alarm_handler.call_system_failure) ''' Get the toppane and child pages ''' self.toppane = self.findChild(QtWidgets.QStackedWidget, "toppane") self.main = self.findChild(QtWidgets.QWidget, "main") self.initial = self.findChild(QtWidgets.QWidget, "initial") self.startup = self.findChild(QtWidgets.QWidget, "startup") self.criticalerrorpage = self.findChild(QtWidgets.QWidget, "criticalerrorpage") ''' Get the center pane (plots) widgets ''' self.centerpane = self.findChild(QtWidgets.QStackedWidget, "centerpane") self.plots_all = self.findChild(QtWidgets.QWidget, "plots_all") self.alarms_settings = self.findChild(QtWidgets.QWidget, "alarms_settings") ''' Get the bottombar and child pages ''' self.bottombar = self.findChild(QtWidgets.QStackedWidget, "bottombar") self.toolbar = self.findChild(QtWidgets.QWidget, "toolbar") self.menu = self.findChild(QtWidgets.QWidget, "menu") self.frozen_bot = self.findChild(QtWidgets.QWidget, "frozenplots_bottom") self.settingsbar = self.findChild(QtWidgets.QWidget, "settingsbar") self.specialbar = self.findChild(QtWidgets.QWidget, "specialbar") self.blank = self.findChild(QtWidgets.QWidget, "blank") self.settingsfork = self.findChild(QtWidgets.QWidget, "settingsforkbar") self.alarmsbar = self.findChild(QtWidgets.QWidget, "alarmsbar") self.numpadbar = self.findChild(QtWidgets.QWidget, "numpadbar") self.criticalerrorbar = self.findChild(QtWidgets.QWidget, "criticalerrorbar") ''' Get the stackable bits on the right ''' self.rightbar = self.main.findChild(QtWidgets.QStackedWidget, "rightbar") self.monitors_bar = self.main.findChild(QtWidgets.QWidget, "monitors_bar") self.frozen_right = self.main.findChild(QtWidgets.QWidget, "frozenplots_right") ''' Get initial and startup buttons ''' self.button_new_patient = self.initial.findChild( QtWidgets.QPushButton, "button_new_patient") self.button_resume_patient = self.initial.findChild( QtWidgets.QPushButton, "button_resume_patient") self.button_resume_patient.setEnabled(self.user_settings != {}) self.button_start_settings = self.startup.findChild( QtWidgets.QPushButton, "button_start_settings") self.button_start_vent = self.startup.findChild( QtWidgets.QPushButton, "button_start_vent") self.button_start_test = self.startup.findChild( QtWidgets.QPushButton, "button_start_test") ''' Get toolbar widgets ''' self.button_menu = self.toolbar.findChild(QtWidgets.QPushButton, "button_menu") self.button_unlockscreen = self.toolbar.findChild( QtWidgets.QPushButton, "button_unlockscreen") self.home_button = self.toolbar.findChild(QtWidgets.QWidget, "home_button") self.goto_menu = self.toolbar.findChild(QtWidgets.QWidget, "goto_menu") self.goto_unlock = self.toolbar.findChild(QtWidgets.QWidget, "goto_unlock") self.label_status = self.toolbar.findChild(QtWidgets.QLabel, "label_status") # Get menu widgets and connect settings for the menu widget self.button_back = self.menu.findChild(QtWidgets.QPushButton, "button_back") self.button_settingsfork = self.menu.findChild(QtWidgets.QPushButton, "button_settingsfork") self.button_startstop = self.menu.findChild(QtWidgets.QPushButton, "button_startstop") self.button_autoassist = self.menu.findChild(QtWidgets.QPushButton, "button_autoassist") self.button_specialops = self.menu.findChild(QtWidgets.QPushButton, "button_specialops") self.button_alarms = self.settingsfork.findChild( QtWidgets.QPushButton, "button_alarms") self.button_settings = self.settingsfork.findChild( QtWidgets.QPushButton, "button_settings") self.button_lockscreen = self.settingsfork.findChild( QtWidgets.QPushButton, "button_lockscreen") self.button_backsettings = self.settingsfork.findChild( QtWidgets.QPushButton, "button_backsettings") self.button_backalarms = self.alarmsbar.findChild( QtWidgets.QPushButton, "button_backalarms") self.button_applyalarm = self.alarmsbar.findChild( QtWidgets.QPushButton, "button_applyalarm") self.button_resetalarm = self.alarmsbar.findChild( QtWidgets.QPushButton, "button_resetalarm") self.button_upalarm = self.alarmsbar.findChild(QtWidgets.QPushButton, "button_upalarm") self.button_downalarm = self.alarmsbar.findChild( QtWidgets.QPushButton, "button_downalarm") self.button_offalarm = self.alarmsbar.findChild( QtWidgets.QPushButton, "button_offalarm") self.button_freeze = self.specialbar.findChild(QtWidgets.QPushButton, "button_freeze") self.button_backspecial = self.specialbar.findChild( QtWidgets.QPushButton, "button_backspecial") # Get frozen plots bottom bar widgets and connect self.button_unfreeze = self.frozen_bot.findChild( QtWidgets.QPushButton, "button_unfreeze") # Connect initial startup buttons self.button_resume_patient.pressed.connect(self.goto_resume_patient) self.button_new_patient.pressed.connect(self.goto_new_patient) self.button_start_vent.pressed.connect(self.goto_main) self.button_start_test.pressed.connect(self.goto_selftest) self.button_spiro_calib.pressed.connect(self.goto_spiro_calibration) self.button_start_settings.pressed.connect(self.goto_settings) # Connect back and menu buttons to toolbar and menu # This effectively defines navigation from the bottombar. # Toolbar self.button_menu.pressed.connect(self.show_menu) # Menu self.button_back.pressed.connect(self.show_toolbar) self.button_alarms.pressed.connect(self.goto_alarms) self.button_settingsfork.pressed.connect(self.show_settingsfork) self.button_specialops.pressed.connect(self.show_specialbar) # Settings self.button_settings.pressed.connect(self.goto_settings) self.button_lockscreen.pressed.connect(self.lock_screen) self.button_backsettings.pressed.connect(self.show_menu) # Special self.button_freeze.pressed.connect(self.freeze_plots) self.button_unfreeze.pressed.connect(self.unfreeze_plots) self.button_backspecial.pressed.connect(self.show_menu) # Confirmation bar self.messagebar = MessageBar(self) self.bottombar.insertWidget(self.bottombar.count(), self.messagebar) # Spirometer Calibration self.spiro_calib.connect_mainwindow_esp32(self, self.esp32) # Self Test self.self_test.connect_mainwindow_esp32_selftestbar( self, self.esp32, self.selftestbar) # Assign unlock screen button and setup state self.unlockscreen_interval = self.config['unlockscreen_interval'] self.button_unlockscreen._state = 0 self.button_unlockscreen.setAutoRepeat(True) self.button_unlockscreen.setAutoRepeatInterval( self.unlockscreen_interval) self.button_unlockscreen.clicked.connect(self.handle_unlock) self.numpad = NumPad(self) self.numpad.assign_code(self.config['unlockscreen_code'], self.unlock_screen) self.numpad.button_back.pressed.connect(self.lock_screen) self.button_backalarms.pressed.connect(self.exit_alarms) #Instantiate the DataFiller, which takes #care of filling plots data self.data_filler = DataFiller(config) #Set up tool settings (bottom bar) #self.toolsettings[..] are the objects that hold min, max values for a given setting as #as the current value (displayed as a slider and as a number). toolsettings_names = { "toolsettings_1", "toolsettings_2", "toolsettings_3" } self.toolsettings = {} for name in toolsettings_names: toolsettings = self.toolbar.findChild(QtWidgets.QWidget, name) toolsettings.connect_config(config) self.toolsettings[name] = toolsettings # Set up data monitor/alarms (side bar) and plots #self.monitors[..] are the objects that hold monitor values and #thresholds for alarm min and max. The current value and #optional stats for the monitored value (mean, max) are set #here. # plot slot widget names self.plots = {} for name in config['plots']: plot = self.main.findChild(QtWidgets.QWidget, name) plot.setFixedHeight(130) self.data_filler.connect_plot(name, plot) self.plots[name] = plot # The monitored fields from the default_settings.yaml config file self.monitors = {} for name in config['monitors']: monitor = Monitor(name, config) self.monitors[name] = monitor self.data_filler.connect_monitor(monitor) # The alarms are from the default_settings.yaml config file # self.alarms = {} # for name in config['alarms']: # alarm = GuiAlarm(name, config, self.monitors, self.alarm_h) # self.alarms[name] = alarm self.gui_alarm = GuiAlarms(config, self.esp32, self.monitors) for monitor in self.monitors.values(): monitor.connect_gui_alarm(self.gui_alarm) # Get displayed monitors self.monitors_slots = self.main.findChild(QtWidgets.QVBoxLayout, "monitors_slots") self.alarms_settings.connect_monitors(self) self.alarms_settings.populate_monitors() self.button_applyalarm.pressed.connect( self.alarms_settings.apply_selected) self.button_resetalarm.pressed.connect( self.alarms_settings.reset_selected) self.button_offalarm.pressed.connect( self.alarms_settings.move_selected_off) self.button_upalarm.pressed.connect( self.alarms_settings.move_selected_up) self.button_downalarm.pressed.connect( self.alarms_settings.move_selected_down) # Connect the frozen plots # Requires building of an ordered array to associate the correct # controls with the plot. active_plots = [] for slotname in self.plots: active_plots.append(self.plots[slotname]) self.cursor = Cursor(active_plots) self.frozen_bot.connect_workers(self.data_filler, active_plots, self.cursor) self.frozen_right.connect_workers(active_plots, self.cursor) #Instantiate DataHandler, which will start a new #thread to read data from the ESP32. We also connect #the DataFiller to it, so the thread will pass the #data directly to the DataFiller, which will #then display them. self._data_h = DataHandler(config, self.esp32, self.data_filler, self.gui_alarm) self.specialbar.connect_datahandler_config_esp32( self._data_h, self.config, self.esp32, self.messagebar) #Connect settings button to Settings overlay. self.settings = Settings(self) self.toppane.insertWidget(self.toppane.count(), self.settings) #Set up start/stop auto/min mode buttons. #Connect each to their respective mode toggle functions. #The StartStopWorker class takes care of starting and stopping a run self._start_stop_worker = StartStopWorker(self, self.config, self.esp32, self.button_startstop, self.button_autoassist, self.toolbar, self.settings) if self._start_stop_worker.is_running(): self.goto_main() self.button_startstop.released.connect( self._start_stop_worker.toggle_start_stop) self.button_autoassist.released.connect( self._start_stop_worker.toggle_mode) self.gui_alarm.connect_workers(self._start_stop_worker)
def _run_keep(arrays_dict, buffers, buffers_to_infiles, buffer_to_outfiles): """ Arguments: ---------- arrays_dict: dictionary mapping each output block index to its list of write blocks buffers: list of Volume objects (see utils.py) representing the read buffers. Each volume contains the coordinates of the buffer in the original image. buffers_to_infiles: maps each read buffer index to the list of input blocks it crosses -> to know which input block to read buffer_to_outfiles: maps each read buffer index to the list of output blocks it crosses -> to only search for the write buffers linked to that read buffer """ cache = dict() voxel_tracker = VoxelTracker() nb_infile_openings = 0 nb_infile_inside_seeks = 0 nb_buffers = len(buffers.keys()) read_time = 0 write_time = 0 from monitor.monitor import Monitor _monitor = Monitor(enable_print=False, enable_log=False, save_data=True) _monitor.disable_clearconsole() _monitor.set_delay(5) _monitor.start() buffer_shape = buffers[0].get_shape() buffer_size = buffer_shape[0] * buffer_shape[1] * buffer_shape[2] * 2 buffer_data = np.empty(copy.deepcopy(buffer_shape), dtype=np.float16) voxel_tracker.add_voxels(buffer_size) # for each read buffer for buffer_index in range(nb_buffers): print("\nBUFFER ", buffer_index, '/', nb_buffers) if DEBUG: print_mem_info() buffer = buffers[buffer_index] nb_opening_seeks_tmp, nb_inside_seeks_tmp, t1, t2 = process_buffer(buffer_data, arrays_dict, buffers, buffer, voxel_tracker, buffers_to_infiles, buffer_to_outfiles, cache) read_time += t1 write_time += t2 nb_infile_openings += nb_opening_seeks_tmp nb_infile_inside_seeks += nb_inside_seeks_tmp if DEBUG: print("End of buffer - Memory info:") print_mem_info() if buffer_index == 1: sys.exit() buffer_data = np.empty(copy.deepcopy(buffer_shape), dtype=np.float16) file_manager.close_infiles() _monitor.stop() ram_pile, swap_pile = _monitor.get_mem_piles() return [read_time, write_time], ram_pile, swap_pile, nb_infile_openings, nb_infile_inside_seeks, voxel_tracker
def test_fetch(self, mock_get): # Assert requests.get calls url = 'http://up.com' expected = Monitor(url, 200, 1, "html text", 1592379760.808488) actual = Monitor(url) actual.fetch() actual.date_time = 1592379760.808488 # setting of date_time is not part of the self.assertEqual(expected, actual) url = 'http://exceotion.com' expected = Monitor(url, None, None, None) actual = Monitor(url) actual.fetch() self.assertEqual(expected, actual)
def run_wrapper(self): Monitor('config_test.yaml').run()
from monitor.monitor import Monitor import time if __name__ == "__main__": _monitor = Monitor() _monitor.system_info() _monitor.start() try: for i in range(50): time.sleep(0.2) finally: _monitor.stop()
from time import sleep from psutil import cpu_percent from monitor.monitor import Monitor from monitor.exiter import Exiter def cpu_utilization(): cpu_percent_strs = [str(percent) for percent in cpu_percent(percpu=True)] return ','.join(cpu_percent_strs) if __name__ == '__main__': monitor = Monitor() monitor.connect() exiter = Exiter() while not exiter.should_exit: monitor.publish(cpu_utilization()) sleep(5) monitor.disconnect()
from monitor.monitor import MonitorSocketThread, Monitor, db if __name__ == '__main__': ips = db.get_all_monitor_ip() monitor = Monitor(ips) monitor_sock_thr = MonitorSocketThread(monitor) monitor_sock_thr.setDaemon(True) monitor_sock_thr.start() monitor.run()
def run_wrapper(self): Monitor('config_empty_config.yaml').run()
def test_class_representation(self): expected = "Monitor()" actual = repr(Monitor()) self.assertEqual(expected, actual)