def setUp(self): self.process = Process("Process") self.context = Context(self.process) pmac_block = make_block_creator(__file__, "test_pmac_manager_block.yaml") self.child = self.create_child_block(pmac_block, self.process, mri_prefix="PMAC", config_dir="/tmp") # These are the child blocks we are interested in self.child_x = self.process.get_controller("BL45P-ML-STAGE-01:X") # self.child_y = self.process.get_controller( # "BL45P-ML-STAGE-01:Y") self.child_cs1 = self.process.get_controller("PMAC:CS1") self.child_traj = self.process.get_controller("PMAC:TRAJ") self.child_status = self.process.get_controller("PMAC:STATUS") # CS1 needs to have the right port otherwise we will error self.set_attributes(self.child_cs1, port="CS1") self.o = BeamSelectorPart( name="beamSelector", mri="PMAC", selectorAxis="x", tomoAngle=0, diffAngle=0.5, moveTime=0.5, ) self.context.set_notify_dispatch_request( self.o.notify_dispatch_request) self.process.start() pass
def setUp(self): self.p = Process('process1') self.context = Context(self.p) # Make a fast child c1 = call_with_params(RunnableController, self.p, [WaitingPart("p", 0.01)], mri="fast", configDir="/tmp") self.p.add_controller("fast", c1) # And a slow one c2 = call_with_params(RunnableController, self.p, [WaitingPart("p", 1.0)], mri="slow", configDir="/tmp") self.p.add_controller("slow", c2) # And a top level one p1 = call_with_params(RunnableChildPart, name="FAST", mri="fast") p2 = call_with_params(RunnableChildPart, name="SLOW", mri="slow") c3 = call_with_params(RunnableController, self.p, [p1, p2], mri="top", configDir="/tmp") self.p.add_controller("top", c3) self.b = self.context.block_view("top") self.bf = self.context.block_view("fast") self.bs = self.context.block_view("slow") # start the process off self.p.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(odin_writer_block, self.process, mri="mri", prefix="prefix") self.mock_when_value_matches(self.child) # set up some values for OdinData PVs that Excalibur would have settings = { "imageHeight": 1536, "imageWidth": 1048, "blockSize": 1, "numProcesses": 4, "dataType": "uint16", } self.set_attributes(self.child, **settings) self.o = OdinWriterPart(name="m", mri="mri") self.context.set_notify_dispatch_request( self.o.notify_dispatch_request) self.process.start() self.completed_steps = 0 # goal for these is 3000, 2000, True cols, rows, alternate = 3000, 2000, False self.steps_to_do = cols * rows xs = LineGenerator("x", "mm", 0.0, 0.5, cols, alternate=alternate) ys = LineGenerator("y", "mm", 0.0, 0.1, rows) self.generator = CompoundGenerator([ys, xs], [], [], 0.1) self.generator.prepare()
def setUp(self): self.p = Process('process1') self.context = Context(self.p) # Make a ticker_block block to act as our child for c in ticker_block(mri="childBlock", config_dir="/tmp"): self.p.add_controller(c) self.b_child = self.context.block_view("childBlock") # Make an empty part for our parent part1 = Part("part1") # Make a RunnableChildPart to control the ticker_block part2 = RunnableChildPart(mri='childBlock', name='part2', initial_visibility=True) # create a root block for the RunnableController block to reside in self.c = RunnableController(mri='mainBlock', config_dir="/tmp") self.c.add_part(part1) self.c.add_part(part2) self.p.add_controller(self.c) self.b = self.context.block_view("mainBlock") self.ss = self.c.state_set # start the process off self.checkState(self.ss.DISABLED) self.p.start() self.checkState(self.ss.READY)
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(stats_plugin_block, self.process, mri="BLOCK:STAT", prefix="prefix")
def setUp(self): self.p = Process('process1') self.context = Context(self.p) # Make a ticker_block block to act as our child self.c_child = call_with_params(ticker_block, self.p, mri="childBlock", configDir="/tmp") self.b_child = self.context.block_view("childBlock") # Make an empty part for our parent part1 = Part("part1") # Make a RunnableChildPart to control the ticker_block part2 = call_with_params(RunnableChildPart, mri='childBlock', name='part2') # create a root block for the RunnableController block to reside in self.c = call_with_params(RunnableController, self.p, [part1, part2], mri='mainBlock', configDir="/tmp", axesToMove=["x"]) self.p.add_controller('mainBlock', self.c) self.b = self.context.block_view("mainBlock") self.ss = self.c.stateSet # start the process off self.checkState(self.ss.DISABLED) self.p.start() self.checkState(self.ss.READY)
def _get_blocks(context: Context, panda_mri: str) -> List[Block]: """Get panda, seqA and seqB Blocks using the given context""" # {part_name: export_name} panda = context.block_view(panda_mri) seq_part_names = {} for source, export in panda.exports.value.rows(): if export in SEQ_TABLES: assert source.endswith( ".table" ), "Expected export %s to come from SEQx.table, got %s" % (export, source) seq_part_names[source[:-len(".table")]] = export assert (tuple(sorted(seq_part_names.values())) == SEQ_TABLES ), "Expected exported attributes %s, got %s" % ( SEQ_TABLES, panda.exports.value.export, ) # {export_name: mri} seq_mris = {} for name, mri, _, _, _ in panda.layout.value.rows(): if name in seq_part_names: export = seq_part_names[name] seq_mris[export] = mri assert sorted(seq_mris) == sorted(seq_part_names.values( )), "Couldn't find MRI for some of %s" % (seq_part_names.values(), ) blocks = [panda] blocks += [context.block_view(seq_mris[x]) for x in SEQ_TABLES] return blocks
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(hdf_writer_block, self.process, mri="BLOCK:HDF5", prefix="prefix") self.process.start()
def abort_after_1s(self): # Need a new context as in a different cothread c = Context(self.p) b = c.block_view("mainBlock") c.sleep(1.0) self.checkState(self.ss.RUNNING) b.abort() self.checkState(self.ss.ABORTED)
class TestRunnableControllerCollectsAllParams(unittest.TestCase): def setUp(self): self.p = Process('process1') self.context = Context(self.p) def tearDown(self): self.p.stop(timeout=1) def test_no_hook_passes(self): # create a root block for the RunnableController block to reside in self.c = call_with_params( RunnableController, self.p, [PartTester1("1"), PartTester2("2")], mri='mainBlock', configDir="/tmp", axesToMove=["x"]) self.p.add_controller('mainBlock', self.c) self.b = self.context.block_view("mainBlock") # start the process off self.p.start() takes = list(self.b.configure.takes.elements) self.assertEqual(takes, ["size", "generator", "axesToMove"]) def test_hook_fails(self): # create a root block for the RunnableController block to reside in self.c = call_with_params( RunnableController, self.p, [PartTester1("1"), PartTester3("2")], mri='mainBlock', configDir="/tmp", axesToMove=["x"]) self.p.add_controller('mainBlock', self.c) self.b = self.context.block_view("mainBlock") # start the process off self.p.start() takes = list(self.b.configure.takes.elements) self.assertEqual(takes, ["size", "generator", "axesToMove"]) def test_hook_plus_method_takes_nothing_passes(self): # create a root block for the RunnableController block to reside in self.c = call_with_params( RunnableController, self.p, [PartTester1("1"), PartTester4("2")], mri='mainBlock', configDir="/tmp", axesToMove=["x"]) self.p.add_controller('mainBlock', self.c) self.b = self.context.block_view("mainBlock") # start the process off self.p.start() takes = list(self.b.configure.takes.elements) self.assertEqual(takes, ["size", "generator", "axesToMove"])
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( position_labeller_block, self.process, mri="BLOCK-POS", prefix="prefix" ) self.o = PositionLabellerPart(name="m", mri="BLOCK-POS") self.context.set_notify_dispatch_request(self.o.notify_dispatch_request) self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( xmap_driver_block, self.process, mri="mri", prefix="prefix" ) self.mock_when_value_matches(self.child) self.o = XmapDriverPart(name="m", mri="mri", runs_on_windows=True) self.context.set_notify_dispatch_request(self.o.notify_dispatch_request) self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(reframe_plugin_block, self.process, mri="mri", prefix="prefix") self.mock_when_value_matches(self.child) self.o = ReframePluginPart(name="m", mri="mri") self.context.set_notify_dispatch_request( self.o.notify_dispatch_request) self.process.start()
class TestIocIconPart(unittest.TestCase): def add_part_and_start(self): self.icon = IocIconPart( "ICON", os.path.split(__file__)[0] + "/../../../malcolm/modules/system/icons/epics-logo.svg", ) self.c1.add_part(self.icon) self.p.add_controller(self.c1) self.p.start() def setUp(self): self.p = Process("process1") self.context = Context(self.p) self.c1 = RunnableController(mri="SYS", config_dir="/tmp", use_git=False) def tearDown(self): self.p.stop(timeout=1) @patch("malcolm.modules.ca.util.CAAttribute") def test_has_pv(self, CAAttribute): self.add_part_and_start() CAAttribute.assert_called_once_with( ANY, catools.DBR_STRING, "", "ICON:KERNEL_VERS", throw=False, callback=self.icon.update_icon, ) assert isinstance(CAAttribute.call_args[0][0], StringMeta) meta = CAAttribute.call_args[0][0] assert meta.description == "Host Architecture" assert not meta.writeable assert len(meta.tags) == 0 def test_adds_correct_icons(self): self.add_part_and_start() assert self.context.block_view("SYS").icon.value == defaultIcon arch = MockPv("windows") self.icon.update_icon(arch) assert self.context.block_view("SYS").icon.value == winIcon arch = MockPv("WIND") self.icon.update_icon(arch) assert self.context.block_view("SYS").icon.value == vxIcon arch = MockPv("linux") self.icon.update_icon(arch) assert self.context.block_view("SYS").icon.value == linuxIcon
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.cs = self.create_child_block(cs_block, self.process, mri="PMAC:CS1", prefix="PV:CSPRE") self.child = self.create_child_block(pmac_trajectory_block, self.process, mri="PMAC:TRAJ", prefix="PV:PRE") self.o = PmacTrajectoryPart(name="pmac", mri="PMAC:TRAJ") self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(andor_driver_block, self.process, mri="mri", prefix="prefix") self.mock_when_value_matches(self.child) # readoutTime used to be 0.002, not any more... self.andor_driver_part = AndorDriverPart(name="m", mri="mri") self.context.set_notify_dispatch_request( self.andor_driver_part.notify_dispatch_request) self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( eiger_driver_block, self.process, mri="mri", prefix="prefix", fan_prefix="FAN", ) self.o = EigerDriverPart(name="m", mri="mri") self.context.set_notify_dispatch_request(self.o.notify_dispatch_request) self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.mri = "mri" self.child = self.create_child_block(ethercat_driver_block, self.process, mri=self.mri, prefix="prefix") self.mock_when_value_matches(self.child) self.ethercat_driver_part = EthercatDriverPart(name="m", mri="mri") self.context.set_notify_dispatch_request( self.ethercat_driver_part.notify_dispatch_request) self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block(pmac_trajectory_block, self.process, mri="PMAC:TRAJ", prefix="PV:PRE", statPrefix="PV:STAT") self.child.parts["i10"].attr.set_value(1705244) self.o = call_with_params(PmacTrajectoryPart, name="pmac", mri="PMAC:TRAJ") list(self.o.create_attribute_models()) self.process.start()
def s_server_hello_with_malcolm_client(self): from malcolm.core import call_with_params, Context, ResponseError from malcolm.blocks.builtin import proxy_block call_with_params(proxy_block, self.process2, mri="hello", comms="client") context = Context(self.process2) context.when_matches(["hello", "health", "value"], "OK", timeout=2) block2 = self.process2.block_view("hello") ret = block2.greet(name="me2") assert ret == dict(greeting="Hello me2") with self.assertRaises(ResponseError): block2.error()
def test_set_export_parts(self): context = Context(self.p) b = context.block_view("mainBlock") assert list(b) == [ 'meta', 'health', 'state', 'layout', 'design', 'exports', 'modified', 'disable', 'reset', 'save', 'attr' ] new_exports = Table(self.c.exports.meta) new_exports.append(('part2.attr', 'childAttr')) new_exports.append(('part2.reset', 'childReset')) self.c.set_exports(new_exports) assert self.c.modified.value == True assert self.c.modified.alarm.message == "exports changed" call_with_params(self.c.save, design='testSaveLayout') assert self.c.modified.value == False # block has changed, get a new view b = context.block_view("mainBlock") assert list(b) == [ 'meta', 'health', 'state', 'layout', 'design', 'exports', 'modified', 'disable', 'reset', 'save', 'attr', 'childAttr', 'childReset' ] assert self.c.state.value == "Ready" assert b.childAttr.value == "defaultv" assert self.c.modified.value == False m = MagicMock() f = b.childAttr.subscribe_value(m) # allow a subscription to come through context.sleep(0.1) m.assert_called_once_with("defaultv") m.reset_mock() self.c_part.attr.set_value("newv") assert b.childAttr.value == "newv" assert self.c_part.attr.value == "newv" assert self.c.modified.value == True assert self.c.modified.alarm.message == \ "part2.attr.value = 'newv' not 'defaultv'" # allow a subscription to come through context.sleep(0.1) m.assert_called_once_with("newv") b.childAttr.put_value("again") assert b.childAttr.value == "again" assert self.c_part.attr.value == "again" assert self.c.modified.value == True assert self.c.modified.alarm.message == \ "part2.attr.value = 'again' not 'defaultv'" # remove the field new_exports = Table(self.c.exports.meta) self.c.set_exports(new_exports) assert self.c.modified.value == True call_with_params(self.c.save) assert self.c.modified.value == False # block has changed, get a new view b = context.block_view("mainBlock") assert "childAttr" not in b
def cs_axis_numbers( context: Context, layout_table: builtin.util.LayoutTable, cs_port: str, ) -> Dict[str, int]: """Given the layout table of a PMAC, get the axis number for each name in the table which is in the specified CS""" axis_numbers = {} for name, mri in zip(layout_table.name, layout_table.mri): child = context.block_view(mri) try: axis_number = child.axisNumber.value except (AttributeError, KeyError): axis_number = None try: cs = child.cs.value except (AttributeError, KeyError): cs = None if cs and axis_number: child_cs_port = child.cs.value.split(",", 1)[0] if cs_port == child_cs_port: if name in axis_numbers: axis_numbers[name] = axis_number else: axis_numbers[name] = axis_number return axis_numbers
class TestMotorPreMovePart(ChildTestCase): def setUp(self): self.process = Process("test_process") self.context = Context(self.process) # Create a raw motor mock to handle axis request self.child = self.create_child_block(raw_motor_block, self.process, mri="BS", pv_prefix="PV:PRE") # Add Beam Selector object self.o = MotorPreMovePart(name="MotorPreMovePart", mri="BS", demand=50) controller = RunnableController("SCAN", "/tmp") controller.add_part(self.o) self.process.add_controller(controller) self.process.start() def tearDown(self): del self.context self.process.stop(timeout=1) def test_bs(self): b = self.context.block_view("SCAN") generator = CompoundGenerator([LineGenerator("x", "mm", 0, 1, 10)], [], [], 0.1) b.configure(generator) self.o.on_configure(self.context) assert self.child.handled_requests.mock_calls == [ call.put("demand", 50) ]
def setUp(self): self.process = Process("test_process") self.context = Context(self.process) # Create a raw motor mock to handle axis request self.child = self.create_child_block( raw_motor_block, self.process, mri="BS", pv_prefix="PV:PRE" ) # Add Beam Selector object self.o = MotorPreMovePart(name="MotorPreMovePart", mri="BS", demand=50) controller = RunnableController("SCAN", "/tmp", use_git=False) controller.add_part(self.o) self.process.add_controller(controller) self.process.start()
def setUp(self): self.p = Process("process1") self.context = Context(self.p) self.c1 = RunnableController(mri="SYS", config_dir="/tmp") self.tmp_dir = f"/tmp/{now}-{os.getpid()}" os.mkdir(self.tmp_dir) os.mkdir(self.tmp_dir + "/configure")
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( stats_plugin_block, self.process, mri="BLOCK-STAT", prefix="prefix") self.o = StatsPluginPart(name="m", mri="BLOCK-STAT") self.process.start()
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( reframe_plugin_block, self.process, mri="mri", prefix="prefix") self.o = ReframePluginPart(name="m", mri="mri") self.process.start()
def abort_detector(self, context: Context) -> None: child = context.block_view(self.mri) child.stop() # Stop is a put to a busy record which returns immediately # The detector might take a while to actually stop so use the # acquiring pv (which is the same asyn parameter as the busy record # that stop() pokes) to check that it has finished child.when_value_matches("acquiring", False, timeout=DEFAULT_TIMEOUT)
def test_save(self): assert self.c.design.value == "" assert self.c.design.meta.choices == [""] c = Context(self.p) li = [] c.subscribe(["mainBlock", "design", "meta"], li.append) # Wait for long enough for the other process to get a look in c.sleep(0.1) assert len(li) == 1 assert li.pop()["choices"] == [""] b = c.block_view("mainBlock") design_name = "testSaveLayout" b.save(designName=design_name) assert len(li) == 3 assert li[0]["writeable"] is False assert li[1]["choices"] == ["", design_name] assert li[2]["writeable"] is True assert self.c.design.meta.choices == ["", design_name] self.check_expected_save(design_name) assert self.c.state.value == "Ready" assert self.c.design.value == design_name assert self.c.modified.value is False os.remove(self._get_design_filename(self.main_block_name, design_name)) self.c_part.attr.set_value("newv") assert self.c.modified.value is True assert (self.c.modified.alarm.message == "part2.attr.value = 'newv' not 'defaultv'") self.c.save(designName="") self.check_expected_save(design_name, attr="newv") assert self.c.design.value == "testSaveLayout"
def setUp(self): self.process = Process("Process") self.context = Context(self.process) self.child = self.create_child_block( xmap_detector_driver_block, self.process, mri="mri", prefix="prefix") self.o = call_with_params(XmapDriverPart, name="m", mri="mri") list(self.o.create_attribute_models()) self.process.start()