def setUp(self): self.app = Application.Application(TestUI.UserInterface(), set_global=False) self.source_image = numpy.random.randn(1024, 1024).astype(numpy.float32) self.exposure = 1.0 HardwareSource.HardwareSourceManager().hardware_sources = [] HardwareSource.HardwareSourceManager().hardware_source_added_event = Event.Event() HardwareSource.HardwareSourceManager().hardware_source_removed_event = Event.Event()
def test_recorder_state_is_reported_properly(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.ones((8, 8))) document_model.append_data_item(data_item) recorder_state_ref = ["unknown"] def recorder_state_changed(recorder_state): recorder_state_ref[0] = recorder_state recorder = RecorderPanel.Recorder(document_controller, data_item) recorder.on_recording_state_changed = recorder_state_changed with contextlib.closing(recorder): with document_model.data_item_live(data_item): count = 4 recorder.start_recording(10, 1, count) for i in range(count): recorder.continue_recording(10 + i + 0.25) data_item.set_data(data_item.data + 1) if i != count - 1: # last iteration it should fall out of transaction state since it is finished self.assertEqual(recorder_state_ref[0], "recording") else: self.assertEqual(recorder_state_ref[0], "stopped") self.assertEqual(recorder_state_ref[0], "stopped")
def test_data_item_display_thumbnail_source_produces_data_item_mime_data( self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.random.randn(8, 8)) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_item.display_type = "image" thumbnail_source = DataItemThumbnailWidget.DataItemThumbnailSource( app.ui) finished = threading.Event() def thumbnail_data_changed(data): finished.set() thumbnail_source.on_thumbnail_data_changed = thumbnail_data_changed thumbnail_source.set_display_item(display_item) finished.wait(1.0) finished.clear() finished.wait(1.0) mime_data = app.ui.create_mime_data() valid, thumbnail = thumbnail_source.populate_mime_data_for_drag( mime_data, Geometry.IntSize(64, 64)) self.assertTrue(valid) self.assertIsNotNone(thumbnail) self.assertTrue( mime_data.has_format(MimeTypes.DISPLAY_ITEM_MIME_TYPE))
def test_launch_with_no_project_then_cancel_open_dialog(self): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) app.initialize(load_plug_ins=False) try: # ensure no project references self.assertEqual(0, len(profile.project_references)) # set up mock calls to get through start call and check conditions app.ui.get_file_paths_dialog = unittest.mock.Mock( return_value=([], str(), str())) app.show_ok_dialog = unittest.mock.Mock() app.show_ok_dialog.side_effect = press_ok_and_complete app.show_choose_project_dialog = unittest.mock.Mock() app.show_choose_project_dialog.side_effect = app.show_open_project_dialog # start the app app.start(profile=profile) # check the mock calls app.ui.get_file_paths_dialog.assert_called_once() app.show_choose_project_dialog.assert_called_once() app.show_ok_dialog.assert_not_called() # ensure no project is loaded self.assertEqual(0, len(profile.project_references)) self.assertEqual(0, len(app.windows)) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def test_launch_with_no_project_then_open_a_project_with_error(self): # test both json error and general storage error for uuid_error, storage_error in ((True, False), (False, True)): with self.subTest(uuid_error=uuid_error, storage_error=storage_error): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) app.initialize(load_plug_ins=False) try: # ensure no project references self.assertEqual(0, len(profile.project_references)) # set up mock calls to get through start call def setup_bad_project(args): project_reference = TestContext.add_project_memory( profile, load=False, make_uuid_error=uuid_error, make_storage_error=storage_error) return project_reference app.show_choose_project_dialog = unittest.mock.Mock() app.show_choose_project_dialog.side_effect = app.show_open_project_dialog profile.open_project = unittest.mock.Mock() profile.open_project.side_effect = setup_bad_project app.ui.get_file_paths_dialog = unittest.mock.Mock() app.ui.get_file_paths_dialog.side_effect = [ (["PATH"], str(), str()), ([], str(), str()) ] app.show_ok_dialog = unittest.mock.Mock() app.show_ok_dialog.side_effect = press_ok_and_complete logging.getLogger( "loader").setLevel = unittest.mock.Mock( ) # ignore this call # start the app app.start(profile=profile) # check the mock calls self.assertEqual( 2, len(app.ui.get_file_paths_dialog.mock_calls)) profile.open_project.assert_called_once() app.show_ok_dialog.assert_called_once() # ensure a single project is loaded self.assertEqual(1, len(profile.project_references)) self.assertEqual( "invalid", profile.project_references[0].project_state) self.assertEqual(0, len(app.windows)) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def setUp(self): self.app = Application.Application(TestUI.UserInterface(), set_global=False) self.t = FilterPanel.TreeNode() self.t.insert_value(["1969", "02"], "Chris") self.t.insert_value(["1965", "12"], "Hans") self.t.insert_value(["1970", "02"], "Lara") self.t.insert_value(["2000", "06"], "Julian") self.t.insert_value(["2000", "03"], "Holden") self.t.insert_value(["2000", "06"], "Tristan") self.t.insert_value(["2000", "06"], "Skywalker")
def main(args, bootstrap_args): from nion.swift import Facade from nion.swift import Application from nion.ui import Application as ApplicationUI warnings.simplefilter("always", RuntimeWarning) Facade.initialize() app = Application.Application(ApplicationUI.make_ui(bootstrap_args)) app.initialize(use_root_dir=False) Facade.start_server() return app
def create_document_controller_with_application( self) -> DocumentController.DocumentController: app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = self.create_document_model(auto_close=False) document_controller = app.create_document_controller( document_model, "library") self.__items_exit.append(document_controller.close) self.__app = app # hold a reference app._set_document_model( document_model) # required to allow API to find document model return document_controller
def test_launch_with_no_project_then_open_a_project_needing_upgrade_but_unable_to_upgrade( self): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) app.initialize(load_plug_ins=False) try: # ensure no project references self.assertEqual(0, len(profile.project_references)) # set up mock calls to get through start call def setup_needs_upgrade_project(args): project_reference = TestContext.add_project_memory( profile, load=False, d={"version": 0}) return project_reference profile.open_project = unittest.mock.Mock() profile.open_project.side_effect = setup_needs_upgrade_project app.ui.get_file_paths_dialog = unittest.mock.Mock() app.ui.get_file_paths_dialog = unittest.mock.Mock( return_value=(["PATH"], str(), str())) app.show_choose_project_dialog = unittest.mock.Mock() app.show_choose_project_dialog.side_effect = app.show_open_project_dialog app.show_ok_cancel_dialog = unittest.mock.Mock() app.show_ok_cancel_dialog.side_effect = press_ok_cancel_and_ok_complete app.show_ok_dialog = unittest.mock.Mock() profile.upgrade = unittest.mock.Mock() profile.upgrade.side_effect = FileExistsError() logging.getLogger("loader").setLevel = unittest.mock.Mock( ) # ignore this call # start the app app.start(profile=profile) # check the mock calls self.assertEqual(1, len(app.ui.get_file_paths_dialog.mock_calls)) profile.open_project.assert_called_once() app.show_choose_project_dialog.assert_called_once() app.show_ok_cancel_dialog.assert_called_once() app.show_ok_dialog.assert_called_once() # ensure a single project is loaded self.assertEqual(1, len(profile.project_references)) self.assertEqual(0, len(app.windows)) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def test_data_item_removed_implicitly_from_data_group_undo_redo(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): # setup three data items and put in a group data_item1 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item2 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item3 = DataItem.DataItem(numpy.random.randn(4, 4)) document_model.append_data_item(data_item1) document_model.append_data_item(data_item2) document_model.append_data_item(data_item3) data_group = DataGroup.DataGroup() display_item1 = document_model.get_display_item_for_data_item( data_item1) display_item2 = document_model.get_display_item_for_data_item( data_item2) display_item3 = document_model.get_display_item_for_data_item( data_item3) data_group.append_display_item(display_item1) data_group.append_display_item(display_item2) data_group.append_display_item(display_item3) document_model.append_data_group(data_group) # remove the 2nd data item command = document_controller.create_remove_data_items_command( [data_item2]) command.perform() document_controller.push_undo_command(command) self.assertEqual(2, len(document_model.data_items)) self.assertEqual(2, len(data_group.display_items)) self.assertEqual(document_model.display_items[0], data_group.display_items[0]) self.assertEqual(document_model.display_items[1], data_group.display_items[1]) # undo and check document_controller.handle_undo() self.assertEqual(3, len(document_model.data_items)) self.assertEqual(3, len(data_group.display_items)) self.assertEqual(document_model.display_items[0], data_group.display_items[0]) self.assertEqual(document_model.display_items[1], data_group.display_items[1]) self.assertEqual(document_model.display_items[2], data_group.display_items[2]) # redo and check document_controller.handle_redo() self.assertEqual(2, len(document_model.data_items)) self.assertEqual(2, len(data_group.display_items)) self.assertEqual(document_model.display_items[0], data_group.display_items[0]) self.assertEqual(document_model.display_items[1], data_group.display_items[1])
def test_inserting_items_data_group_undo_redo(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController(app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): # setup three data items and put in a group data_item1 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item3 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item4 = DataItem.DataItem(numpy.random.randn(4, 4)) document_model.append_data_item(data_item1) document_model.append_data_item(data_item3) document_model.append_data_item(data_item4) data_group = DataGroup.DataGroup() display_item1 = document_model.get_display_item_for_data_item(data_item1) display_item3 = document_model.get_display_item_for_data_item(data_item3) display_item4 = document_model.get_display_item_for_data_item(data_item4) data_group.append_display_item(display_item1) data_group.append_display_item(display_item3) document_model.append_data_group(data_group) self.assertEqual(3, len(document_model.data_items)) self.assertEqual(2, len(data_group.display_items)) self.assertListEqual([data_item1, data_item3, data_item4], list(document_model.data_items)) self.assertListEqual([display_item1, display_item3], list(data_group.display_items)) # insert new items data_item2 = DataItem.DataItem(numpy.random.randn(4, 4)) document_model.append_data_item(data_item2) display_item2 = document_model.get_display_item_for_data_item(data_item2) command = DocumentController.DocumentController.InsertDataGroupDataItemsCommand(document_controller, data_group, [data_item2, data_item4], 1) command.perform() document_controller.push_undo_command(command) self.assertEqual(4, len(document_model.data_items)) self.assertEqual(4, len(data_group.display_items)) self.assertListEqual([data_item1, data_item3, data_item4, data_item2], list(document_model.data_items)) self.assertListEqual([display_item1, display_item2, display_item4, display_item3], list(data_group.display_items)) # undo and check document_controller.handle_undo() self.assertEqual(4, len(document_model.data_items)) self.assertEqual(2, len(data_group.display_items)) self.assertListEqual([data_item1, data_item3, data_item4, data_item2], list(document_model.data_items)) self.assertListEqual([display_item1, display_item3], list(data_group.display_items)) # redo and check document_controller.handle_redo() data_item2 = document_model.data_items[3] self.assertEqual(4, len(document_model.data_items)) self.assertEqual(4, len(data_group.display_items)) self.assertListEqual([data_item1, data_item3, data_item4, data_item2], list(document_model.data_items)) self.assertListEqual([display_item1, display_item2, display_item4, display_item3], list(data_group.display_items))
def test_deleting_data_items_out_of_order_from_data_group_undo_redo(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): # setup three data items in a group data_item1 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item2 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item3 = DataItem.DataItem(numpy.random.randn(4, 4)) document_model.append_data_item(data_item1) document_model.append_data_item(data_item2) document_model.append_data_item(data_item3) data_group = DataGroup.DataGroup() display_item1 = document_model.get_display_item_for_data_item( data_item1) display_item2 = document_model.get_display_item_for_data_item( data_item2) display_item3 = document_model.get_display_item_for_data_item( data_item3) data_group.append_display_item(display_item1) data_group.append_display_item(display_item2) data_group.append_display_item(display_item3) document_model.append_data_group(data_group) # remove two of the three command = DocumentController.DocumentController.RemoveDataGroupDisplayItemsCommand( document_model, data_group, [display_item3, display_item1]) command.perform() document_controller.push_undo_command(command) self.assertEqual(1, len(data_group.display_items)) self.assertEqual(0, len(data_group.data_groups)) self.assertEqual(display_item2, data_group.display_items[0]) # undo and check document_controller.handle_undo() self.assertEqual(3, len(data_group.display_items)) self.assertEqual(0, len(data_group.data_groups)) self.assertEqual(display_item1, data_group.display_items[0]) self.assertEqual(display_item2, data_group.display_items[1]) self.assertEqual(display_item3, data_group.display_items[2]) # redo and check document_controller.handle_redo() self.assertEqual(1, len(data_group.display_items)) self.assertEqual(0, len(data_group.data_groups)) self.assertEqual(display_item2, data_group.display_items[0])
def test_launch_with_no_project_then_open_a_project(self): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) app.initialize(load_plug_ins=False) try: # ensure no project references self.assertEqual(0, len(profile.project_references)) # set up mock calls to get through start call profile.open_project = unittest.mock.Mock() profile.open_project.side_effect = lambda x: TestContext.add_project_memory( profile, load=False) app.ui.get_file_paths_dialog = unittest.mock.Mock( return_value=(["PATH"], str(), str())) app.show_ok_dialog = unittest.mock.Mock() app.show_ok_dialog.side_effect = press_ok_and_complete app.show_choose_project_dialog = unittest.mock.Mock() app.show_choose_project_dialog.side_effect = app.show_open_project_dialog logging.getLogger("loader").setLevel = unittest.mock.Mock( ) # ignore this call # start the app app.start(profile=profile) # check the mock calls app.ui.get_file_paths_dialog.assert_called_once() profile.open_project.assert_called_once() app.show_choose_project_dialog.assert_called_once() app.show_ok_dialog.assert_not_called() # ensure a single project is loaded self.assertEqual(1, len(profile.project_references)) self.assertEqual("loaded", profile.project_references[0].project_state) self.assertEqual(1, len(app.windows)) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def test_insert_data_group_undo_redo(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): # setup three data items and put two in a group data_item1 = DataItem.DataItem(numpy.random.randn(4, 4)) data_item3 = DataItem.DataItem(numpy.random.randn(4, 4)) document_model.append_data_item(data_item1) document_model.append_data_item(data_item3) data_group1 = DataGroup.DataGroup() data_group1.append_display_item( document_model.get_display_item_for_data_item(data_item1)) data_group2 = DataGroup.DataGroup() data_group3 = DataGroup.DataGroup() data_group2_uuid = data_group2.uuid data_group3.append_display_item( document_model.get_display_item_for_data_item(data_item3)) document_model.append_data_group(data_group1) document_model.append_data_group(data_group3) # insert the middle data group command = DocumentController.DocumentController.InsertDataGroupCommand( document_model, document_model, 1, data_group2) command.perform() document_controller.push_undo_command(command) self.assertEqual(3, len(document_model.data_groups)) self.assertEqual(data_group1, document_model.data_groups[0]) self.assertEqual(data_group3, document_model.data_groups[2]) self.assertEqual(data_group2_uuid, document_model.data_groups[1].uuid) # undo and check document_controller.handle_undo() self.assertEqual(2, len(document_model.data_groups)) self.assertEqual(data_group1, document_model.data_groups[0]) self.assertEqual(data_group3, document_model.data_groups[1]) # redo and check document_controller.handle_redo() self.assertEqual(3, len(document_model.data_groups)) self.assertEqual(data_group1, document_model.data_groups[0]) self.assertEqual(data_group3, document_model.data_groups[2]) self.assertEqual(data_group2_uuid, document_model.data_groups[1].uuid)
def test_switching_library_closes_document_only_once(self): current_working_directory = os.getcwd() workspace1_dir = os.path.join(current_working_directory, "__Test1") workspace2_dir = os.path.join(current_working_directory, "__Test2") Cache.db_make_directory_if_needed(workspace1_dir) Cache.db_make_directory_if_needed(workspace2_dir) try: app = Application.Application(TestUI.UserInterface(), set_global=False) app.initialize(load_plug_ins=False) app.start(True, fixed_workspace_dir=workspace1_dir) app.switch_library(workspace2_dir, skip_choose=True, fixed_workspace_dir=workspace2_dir) app.exit() app.deinitialize() finally: #logging.debug("rmtree %s", workspace_dir) shutil.rmtree(workspace1_dir) shutil.rmtree(workspace2_dir)
def test_data_group_rename_undo_redo(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController(app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): # setup data group data_group = DataGroup.DataGroup() data_group.title = "ethel" document_model.append_data_group(data_group) # rename command = document_controller.create_rename_data_group_command(data_group, "fred") command.perform() document_controller.push_undo_command(command) self.assertEqual(data_group.title, "fred") # undo and check document_controller.handle_undo() self.assertEqual(data_group.title, "ethel") # redo and check document_controller.handle_redo() self.assertEqual(data_group.title, "fred")
def test_recorder_records_live_data(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.ones((8, 8))) document_model.append_data_item(data_item) recorder = RecorderPanel.Recorder(document_controller, data_item) with contextlib.closing(recorder): with document_model.data_item_live(data_item): count = 4 recorder.start_recording(10, 1, count) for i in range(count): recorder.continue_recording(10 + i + 0.25) recorder.continue_recording(10 + i + 0.75) data_item.set_data(data_item.data + 1) self.assertEqual(2, len(document_model.data_items)) recorded_data_item = document_model.data_items[1] self.assertTrue(recorded_data_item.xdata.is_sequence) self.assertEqual((4, 8, 8), recorded_data_item.xdata.dimensional_shape)
def setUp(self): self.app = Application.Application(TestUI.UserInterface(), set_global=False) self.document_model = DocumentModel.DocumentModel() self.document_controller = DocumentController.DocumentController( self.app.ui, self.document_model, workspace_id="library") data = numpy.full((10, 10), 200, dtype=numpy.uint32) data[5, 5] = 650 self.data_item = DataItem.DataItem(data) self.document_model.append_data_item(self.data_item) self.display_item = self.document_model.get_display_item_for_data_item( self.data_item) self.histogram_panel = HistogramPanel.HistogramPanel( self.document_controller, "histogram-panel", None, debounce=False, sample=False) self.histogram_canvas_item = self.histogram_panel._histogram_widget._histogram_canvas_item self.document_controller.show_display_item(self.display_item) self.histogram_canvas_item.update_layout((0, 0), (80, 300), immediate=True)
def main(args, bootstrap_args): sys.path.insert(0, os.path.join(os.path.dirname(__file__), "nionutils")) sys.path.insert(0, os.path.join(os.path.dirname(__file__), "nionui")) sys.path.insert(0, os.path.join(os.path.dirname(__file__), "niondata")) sys.path.insert(0, os.path.join(os.path.dirname(__file__), "nionswift")) sys.path.insert( 0, os.path.join(os.path.dirname(__file__), "nionswift-instrumentation-kit")) sys.path.insert(0, os.path.join(os.path.dirname(__file__), "nionswift-io")) sys.path.insert(0, os.path.join(os.path.dirname(__file__), "eels-analysis")) # these imports need to occur AFTER the args are parsed and the path # is updated accordingly. from nion.swift import Facade from nion.swift import Application from nion.ui import Application as ApplicationUI warnings.simplefilter("always", RuntimeWarning) Facade.initialize() app = Application.Application(ApplicationUI.make_ui(bootstrap_args)) app.initialize() Facade.start_server() return app
def test_recorder_puts_recorded_data_item_under_transaction(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.ones((8, 8))) document_model.append_data_item(data_item) recorder = RecorderPanel.Recorder(document_controller, data_item) with contextlib.closing(recorder): with document_model.data_item_live(data_item): count = 4 recorder.start_recording(10, 1, count) for i in range(count): recorder.continue_recording(10 + i + 0.25) data_item.set_data(data_item.data + 1) if i != count - 1: # last iteration it should fall out of transaction state since it is finished self.assertTrue(document_model.data_items[1]. in_transaction_state) else: self.assertFalse(document_model.data_items[1]. in_transaction_state) self.assertFalse(document_model.data_items[1].in_transaction_state)
def setUp(self): self.app = Application.Application(TestUI.UserInterface(), set_global=True) self.app.workspace_dir = str()
def setUp(self): self.app = Application.Application(TestUI.UserInterface(), set_global=False)
def test_acquire_multi_eels_spectrum_image(self): scan_size = (10, 10) app = Application.Application(TestUI.UserInterface(), set_global=False) for sum_frames in [True, False]: for bin_spectra in [True, False]: with self.subTest(sum_frames=sum_frames, bin_spectra=bin_spectra): settings = { 'x_shifter': 'EELS_MagneticShift_Offset', 'blanker': 'C_Blank', 'x_shift_delay': 0.05, 'focus': '', 'focus_delay': 0, 'auto_dark_subtract': False, 'bin_spectra': bin_spectra, 'blanker_delay': 0.05, 'sum_frames': sum_frames, 'camera_hardware_source_id': '' } parameters = [{ 'index': 0, 'offset_x': 0, 'exposure_ms': 5, 'frames': 2 }, { 'index': 1, 'offset_x': 160, 'exposure_ms': 8, 'frames': 1 }] with TestContext.create_memory_context() as test_context: document_model = test_context.create_document_model( auto_close=False) document_controller = app.create_document_controller( document_model, "library") with contextlib.ExitStack() as cm: cm.callback(document_controller.close) total_acquisition_time = 0.0 for params in parameters: # the simulator cant go super fast, so make sure we give it enough time total_acquisition_time += params[ 'frames'] * max( params['exposure_ms'], 100 ) * 1e-3 * scan_size[0] * scan_size[1] # add some extra overhead time total_acquisition_time += 0.15 total_acquisition_time += settings[ 'x_shift_delay'] * 2 total_acquisition_time += settings[ 'x_shift_delay'] * 2 stem_controller, camera = self._get_stem_controller_and_camera( is_eels=True) scan_controller = self._get_scan_controller( stem_controller) scan_controller.set_enabled_channels([0, 1]) scan_frame_parameters = scan_controller.get_current_frame_parameters( ) scan_frame_parameters['size'] = scan_size scan_controller.set_current_frame_parameters( scan_frame_parameters) multi_acquire_controller = self._set_up_multi_acquire( settings, parameters, stem_controller) multi_acquire_controller.scan_controller = scan_controller def get_acquisition_handler_fn( multi_acquire_parameters, current_parameters_index, multi_acquire_settings): camera_frame_parameters = camera.get_current_frame_parameters( ) scan_frame_parameters = scan_controller.get_current_frame_parameters( ) camera_frame_parameters[ 'exposure_ms'] = multi_acquire_parameters[ current_parameters_index][ 'exposure_ms'] camera_frame_parameters[ 'processing'] = 'sum_project' if multi_acquire_settings[ 'bin_spectra'] else None scan_frame_parameters.setdefault( 'scan_id', str(uuid.uuid4())) grab_synchronized_info = scan_controller.grab_synchronized_get_info( scan_frame_parameters=scan_frame_parameters, camera=camera, camera_frame_parameters= camera_frame_parameters) camera_data_channel = MultiAcquire.CameraDataChannel( document_model, camera.display_name, grab_synchronized_info, multi_acquire_parameters, multi_acquire_settings, current_parameters_index) enabled_channels = scan_controller.get_enabled_channels( ) enabled_channel_names = [ scan_controller.data_channels[i].name for i in enabled_channels ] scan_data_channel = MultiAcquire.ScanDataChannel( document_model, enabled_channel_names, grab_synchronized_info, multi_acquire_parameters, multi_acquire_settings, current_parameters_index) camera_data_channel.start() scan_data_channel.start() handler = MultiAcquire.SISequenceAcquisitionHandler( camera, camera_data_channel, camera_frame_parameters, scan_controller, scan_data_channel, scan_frame_parameters) listener = handler.camera_data_channel.progress_updated_event.listen( multi_acquire_controller. set_progress_counter) def finish_fn(): listener.close() handler.camera_data_channel.stop() handler.scan_data_channel.stop() handler.finish_fn = finish_fn return handler progress = 0 def update_progress(minimum, maximum, value): nonlocal progress progress = minimum + value / maximum document_controller.periodic() progress_event_listener = multi_acquire_controller.progress_updated_event.listen( update_progress) cm.callback(progress_event_listener.close) starttime = time.time() multi_acquire_controller.start_multi_acquire_spectrum_image( get_acquisition_handler_fn) endtime = time.time() document_controller.periodic() self.assertAlmostEqual(progress, 1, places=1) multi_acquire_data_items = list() haadf_data_items = list() maadf_data_items = list() for data_item in document_model.data_items: if 'MultiAcquire' in data_item.title: if 'HAADF' in data_item.title: haadf_data_items.append(data_item) elif 'MAADF' in data_item.title: maadf_data_items.append(data_item) else: multi_acquire_data_items.append( data_item) self.assertEqual(len(multi_acquire_data_items), len(parameters)) self.assertEqual(len(haadf_data_items), len(parameters)) self.assertEqual(len(maadf_data_items), len(parameters)) camera_frame_parameters = camera.get_current_frame_parameters( ) scan_frame_parameters = scan_controller.get_current_frame_parameters( ) for data_item, haadf_data_item in zip( multi_acquire_data_items, haadf_data_items): with self.subTest(): camera_dims = camera.get_expected_dimensions( camera_frame_parameters['binning']) total_shape = tuple( scan_frame_parameters['size']) haadf_shape = tuple( scan_frame_parameters['size']) index = data_item.xdata.metadata[ 'MultiAcquire.parameters']['index'] if parameters[index][ 'frames'] > 1 and not settings[ 'sum_frames']: total_shape = ( parameters[index]['frames'], ) + total_shape haadf_shape = ( parameters[index]['frames'], ) + haadf_shape if settings['bin_spectra']: total_shape += camera_dims[1:] else: total_shape += camera_dims self.assertSequenceEqual( data_item.data.shape, total_shape) self.assertSequenceEqual( haadf_data_item.data.shape, haadf_shape) self.assertLess(starttime - endtime, total_acquisition_time)
def test_switch_to_project_with_error(self): # test both json error and general storage error for uuid_error, storage_error in ((True, False), (False, True)): with self.subTest(uuid_error=uuid_error, storage_error=storage_error): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) TestContext.add_project_memory(profile, load=False) TestContext.add_project_memory(profile, load=False) app.initialize(load_plug_ins=False) try: # ensure two project references self.assertEqual(2, len(profile.project_references)) profile.last_project_reference = profile.project_references[ 0].uuid logging.getLogger( "loader").setLevel = unittest.mock.Mock( ) # ignore this call app.show_choose_project_dialog = unittest.mock.Mock() app.show_choose_project_dialog.side_effect = app.show_open_project_dialog # start the app app.start(profile=profile) # ensure a single project is loaded self.assertEqual(2, len(profile.project_references)) self.assertEqual( "loaded", profile.project_references[0].project_state) self.assertEqual( "unloaded", profile.project_references[1].project_state) self.assertEqual(1, len(app.windows)) self.assertEqual(profile.last_project_reference, profile.project_references[0].uuid) # switching to an error project should display an ok message with an error, then the file # open dialog (which will be cancelled). no windows should be open at the end. # set up mock calls to get through the switch. if uuid_error: profile.read_project = unittest.mock.Mock() profile.read_project.side_effect = Exception() if storage_error: profile.project_references[ 1].make_storage = unittest.mock.Mock() profile.project_references[ 1].make_storage.side_effect = Exception() app.ui.get_file_paths_dialog = unittest.mock.Mock() app.ui.get_file_paths_dialog.side_effect = [ ([], str(), str()), ([], str(), str()) ] app.show_ok_dialog = unittest.mock.Mock() app.show_ok_dialog.side_effect = press_ok_and_complete logging.getLogger( "loader").setLevel = unittest.mock.Mock( ) # ignore this call # switch project and check app.switch_project_reference( profile.project_references[1]) app.ui.get_file_paths_dialog.assert_called_once() app.show_ok_dialog.assert_called_once() self.assertEqual( "unloaded", profile.project_references[0].project_state) self.assertEqual( "unloaded", profile.project_references[1].project_state) self.assertEqual(0, len(app.windows)) self.assertEqual(profile.last_project_reference, profile.project_references[0].uuid) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def test_switching_project_reloads_new_project_on_relaunch(self): with create_memory_profile_context() as profile_context: # use lower level calls to create the profile and open the window via the app profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) TestContext.add_project_memory(profile, load=False) TestContext.add_project_memory(profile, load=False) app.initialize(load_plug_ins=False) try: # ensure one project reference self.assertEqual(2, len(profile.project_references)) profile.last_project_reference = profile.project_references[ 0].uuid logging.getLogger("loader").setLevel = unittest.mock.Mock( ) # ignore this call # start the app app.start(profile=profile) # ensure a single project is loaded self.assertEqual(2, len(profile.project_references)) self.assertEqual("loaded", profile.project_references[0].project_state) self.assertEqual("unloaded", profile.project_references[1].project_state) self.assertEqual(1, len(app.windows)) self.assertEqual(profile.last_project_reference, profile.project_references[0].uuid) # switch project and check app.switch_project_reference(profile.project_references[1]) self.assertEqual("unloaded", profile.project_references[0].project_state) self.assertEqual("loaded", profile.project_references[1].project_state) self.assertEqual(1, len(app.windows)) self.assertEqual(profile.last_project_reference, profile.project_references[1].uuid) finally: app._set_profile_for_test(None) app.exit() app.deinitialize() # reload and check profile = profile_context.create_profile(add_project=False) profile.read_profile() app = Application.Application(TestUI.UserInterface(), set_global=False) app._set_profile_for_test(profile) app.initialize(load_plug_ins=False) try: # ensure two project references self.assertEqual(2, len(profile.project_references)) profile.last_project_reference = profile.project_references[ 0].uuid # start the app app.start(profile=profile) # switch project and check app.switch_project_reference(profile.project_references[1]) self.assertEqual("unloaded", profile.project_references[0].project_state) self.assertEqual("loaded", profile.project_references[1].project_state) self.assertEqual(1, len(app.windows)) self.assertEqual(profile.last_project_reference, profile.project_references[1].uuid) finally: app._set_profile_for_test(None) app.exit() app.deinitialize()
def test_acquire_multi_eels_spectrum_image_produces_data_of_correct_shape( self): for sum_frames in [True, False]: for bin_spectra in [True, False]: with self.subTest(sum_frames=sum_frames, bin_spectra=bin_spectra): settings = { 'x_shifter': 'EELS_MagneticShift_Offset', 'blanker': 'C_Blank', 'x_shift_delay': 0.05, 'focus': '', 'focus_delay': 0, 'auto_dark_subtract': False, 'bin_spectra': bin_spectra, 'blanker_delay': 0.05, 'sum_frames': sum_frames, 'camera_hardware_source_id': '' } parameters = [{ 'index': 0, 'offset_x': 0, 'exposure_ms': 5, 'frames': 2 }, { 'index': 1, 'offset_x': 160, 'exposure_ms': 8, 'frames': 1 }] app = Application.Application(TestUI.UserInterface(), set_global=True) document_model = DocumentModel.DocumentModel() document_controller = app.create_document_controller( document_model, None) total_acquisition_time = 0.0 for parms in parameters: # the simulator cant go super fast, so make sure we give it enough time total_acquisition_time += parms['frames'] * max( parms['exposure_ms'], 100) * 1e-3 # add some extra overhead time total_acquisition_time += 0.15 total_acquisition_time += settings['x_shift_delay'] * 2 total_acquisition_time += settings['x_shift_delay'] * 2 api = Facade.get_api('~1.0', '~1.0') si_receiver = MultiAcquirePanel.MultiAcquirePanelDelegate( api) si_receiver._MultiAcquirePanelDelegate__progress_updated_event_listener.close( ) si_receiver._MultiAcquirePanelDelegate__progress_updated_event_listener = None si_receiver._MultiAcquirePanelDelegate__multi_eels_parameters_changed_event_listener.close( ) si_receiver._MultiAcquirePanelDelegate__multi_eels_parameters_changed_event_listener = None si_receiver._MultiAcquirePanelDelegate__acquisition_state_changed_event_listener.close( ) si_receiver._MultiAcquirePanelDelegate__acquisition_state_changed_event_listener = None multi_acquire = self._set_up_multi_acquire( settings, parameters, multi_acquire_instance=si_receiver. multi_acquire_controller) multi_acquire.stem_controller, multi_acquire.camera = self._get_stem_controller_and_camera( is_eels=True) multi_acquire.superscan = self._get_scan_controller( multi_acquire.stem_controller) # enable binning for speed frame_parameters = multi_acquire.camera.get_current_frame_parameters( ) frame_parameters['binning'] = 8 multi_acquire.camera.set_current_frame_parameters( frame_parameters) scan_frame_parameters = multi_acquire.superscan.get_current_frame_parameters( ) scan_frame_parameters['size'] = (10, 10) scan_frame_parameters['fov_size_nm'] = 16 multi_acquire.superscan.set_current_frame_parameters( scan_frame_parameters) progress = 0 def update_progress(minimum, maximum, value): nonlocal progress progress = minimum + value / maximum document_controller.periodic() progress_event_listener = multi_acquire.progress_updated_event.listen( update_progress) new_data_ready_event_listener = multi_acquire.new_data_ready_event.listen( si_receiver.add_to_display_queue) def acquisition_state_changed(info_dict): if info_dict.get('message') in { 'end processing', 'exception' }: si_receiver._data_processed_event.set() acquisition_state_changed_event_listener = multi_acquire.acquisition_state_changed_event.listen( acquisition_state_changed) data_receiver_thread = threading.Thread( target=si_receiver.process_display_queue, daemon=True) data_receiver_thread.start() # starttime = time.time() multi_acquire.camera.start_playing() multi_acquire.acquire_multi_eels_spectrum_image() document_controller.periodic() self.assertTrue(si_receiver._data_processed_event.wait(10)) self.assertGreaterEqual(progress, 1) #self.assertLess(time.time() - starttime, total_acquisition_time) multi_acquire_data_items = list() for data_item in document_model.data_items: if 'MultiAcquire' in data_item.title: multi_acquire_data_items.append(data_item) self.assertEqual(len(multi_acquire_data_items), len(parameters) * 2) for data_item in multi_acquire_data_items: with self.subTest(): camera_dims = multi_acquire.camera.get_expected_dimensions( frame_parameters['binning']) total_shape = tuple(scan_frame_parameters['size']) haadf_shape = tuple(scan_frame_parameters['size']) index = data_item.xdata.metadata[ 'MultiAcquire.parameters']['index'] if parameters[index]['frames'] > 1 and not settings[ 'sum_frames']: total_shape = (parameters[index]['frames'], ) + total_shape haadf_shape = (parameters[index]['frames'], ) + haadf_shape if settings['bin_spectra']: total_shape += camera_dims[1:] else: total_shape += camera_dims if 'HAADF' in data_item.title: self.assertSequenceEqual( data_item.data.shape, haadf_shape) else: self.assertSequenceEqual( data_item.data.shape, total_shape) data_receiver_thread.join(3) self.assertFalse(data_receiver_thread.is_alive()) progress_event_listener.close() new_data_ready_event_listener.close() acquisition_state_changed_event_listener.close() si_receiver.close() app.exit()
def setUp(self): TestContext.begin_leaks() self.app = Application.Application(TestUI.UserInterface(), set_global=False)
def create_application(self) -> Application.Application: app = Application.Application(TestUI.UserInterface(), set_global=False) self.__app = app # hold a reference return app
def setUp(self): TestContext.begin_leaks() self.app = Application.Application(TestUI.UserInterface(), set_global=True) self.app.workspace_dir = str()