def _make_icon_label(self): block_type = self.block_name.rstrip("0123456789") svg_name = block_type + ".svg" part = call_with_params(IconPart, svg=os.path.join(SVG_DIR, svg_name)) self._add_part("icon", part) part = call_with_params(LabelPart, initialValue=block_type) self._add_part("label", part)
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("proc") self.hello = call_with_params(hello_block, self.process, mri="hello") self.server = call_with_params( web_server_block, self.process, mri="server", port=self.socket) self.result = Queue() self.process.start()
def setUp(self): self.p = Process('process1') # create a child to client self.c_part = MyPart("cp1") self.c_child = call_with_params(StatefulController, self.p, [self.c_part], mri="childBlock") self.p.add_controller("childBlock", self.c_child) part1 = MyPart("part1") part2 = call_with_params(ChildPart, name='part2', mri='childBlock') # create a root block for the ManagerController block to reside in parts = [part1, part2] self.c = call_with_params(ManagerController, self.p, parts, mri='mainBlock', configDir="/tmp") self.p.add_controller("mainBlock", self.c) # check that do_initial_reset works asynchronously assert self.c.state.value == "Disabled" self.p.start() assert self.c.state.value == "Ready"
def test_save(self): self.c._run_git_cmd = MagicMock() call_with_params(self.c.save, design="testSaveLayout") self.check_expected_save() assert self.c.state.value == "Ready" assert self.c.design.value == 'testSaveLayout' assert self.c.modified.value is False os.remove("/tmp/mainBlock/testSaveLayout.json") 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'" call_with_params(self.c.save, design="") self.check_expected_save(attr="newv") assert self.c.design.value == 'testSaveLayout' assert self.c._run_git_cmd.call_args_list == [ call('add', '/tmp/mainBlock/testSaveLayout.json'), call('commit', '--allow-empty', '-m', 'Saved mainBlock testSaveLayout', '/tmp/mainBlock/testSaveLayout.json'), call('add', '/tmp/mainBlock/testSaveLayout.json'), call('commit', '--allow-empty', '-m', 'Saved mainBlock testSaveLayout', '/tmp/mainBlock/testSaveLayout.json') ]
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 test_server_hello_with_malcolm_client(self): call_with_params( proxy_block, self.process2, mri="hello", comms="client") block2 = self.process2.block_view("hello") ret = block2.greet("me2") assert ret == dict(greeting="Hello me2") with self.assertRaises(ResponseError): block2.error()
def set_completed_steps(self, completed_steps): """Seek a Armed or Paused scan back to another value Normally it will return in the state it started in. If the user aborts then it will return in Aborted state. If something goes wrong it will return in Fault state. If the user disables then it will return in Disabled state. """ call_with_params(self.pause, completedSteps=completed_steps)
def makeChildBlock(self, blockMri): controller = call_with_params( BasicController, self.p, [PortsPart(name='Connector%s' % blockMri[-1])], mri=blockMri) part = call_with_params(ChildPart, mri=blockMri, name='part%s' % blockMri) self.p.add_controller(blockMri, controller) return part, controller
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 test_server_counter_with_malcolm_client(self): call_with_params( proxy_block, self.process2, mri="counter", comms="client") block2 = self.process2.block_view("counter") assert block2.counter.value == 0 block2.increment() assert block2.counter.value == 1 block2.zero() assert block2.counter.value == 0 assert self.client.remote_blocks.value == ( "hello", "counter", "server")
def prepare_half_run(self): line1 = LineGenerator('AxisOne', 'mm', 0, 2, 3) line2 = LineGenerator('AxisTwo', 'mm', 0, 2, 2) compound = CompoundGenerator([line1, line2], [], [], 1.0) compound.prepare() call_with_params(self.o.configure, ANY, 0, 2, MagicMock(), generator=compound, axesToMove=['AxisTwo'])
def setUp(self): self.process = Process("proc") self.hello = call_with_params(hello_block, self.process, mri="hello") self.counter = call_with_params( counter_block, self.process, mri="counter") self.server = call_with_params( web_server_block, self.process, mri="server", port=self.socket) self.process.start() self.process2 = Process("proc2") self.client = call_with_params( websocket_client_block, self.process2, mri="client", port=self.socket) self.process2.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 _make_child_controller(self, parts, mri): # Add some extra parts to determine the dataset name and type for # any CAPTURE field part new_parts = [] for existing_part in parts: new_parts.append(existing_part) if existing_part.name.endswith(".CAPTURE"): # Add capture dataset name and type part_name = existing_part.name.replace(".CAPTURE", ".DATASET_NAME") attr_name = snake_to_camel(part_name.replace(".", "_")) new_parts.append( call_with_params( StringPart, name=attr_name, widget="textinput", description="Name of the captured dataset in HDF file", writeable=True, config=True)) # Make a choice part to hold the type of the dataset part_name = existing_part.name.replace(".CAPTURE", ".DATASET_TYPE") attr_name = snake_to_camel(part_name.replace(".", "_")) if "INENC" in mri: initial = "position" else: initial = "monitor" new_parts.append( call_with_params( ChoicePart, name=attr_name, widget="combo", description="Type of the captured dataset in HDF file", writeable=True, choices=attribute_dataset_types, initialValue=initial)) if mri.endswith("PCAP"): new_parts += call_with_params( adbase_parts, self.process, prefix=self.params.areaDetectorPrefix) controller = call_with_params(StatefulController, self.process, new_parts, mri=mri) else: controller = super(PandABlocksRunnableController, self).\ _make_child_controller(new_parts, mri) return controller
def _make_corresponding_part(self, block_name, mri): if block_name == "PCAP": part_cls = PandABlocksDriverPart else: part_cls = PandABlocksChildPart part = call_with_params(part_cls, name=block_name, mri=mri) return part
def setUp(self): svg_name = "/tmp/test_icon.svg" self.svg_text = '<svg><rect width="300" height="100"/></svg>' with open(svg_name, "w") as f: f.write(self.svg_text) self.o = call_with_params(IconPart, svg=svg_name) list(self.o.create_attribute_models())
def create_child_block(self, child_block, process, **params): """Creates an instance of child_block with CA calls mocked out. Args: child_block (callable): The function to call to get the block process (Process): The process to run under **params: Parameters to pass to child_block() Returns: child: The child object with an attribute mock_requests that will have a call.put(attr_name, value) or a call.post(method_name, params) for anything the child is asked to handle """ child = call_with_params(child_block, process, **params) child.handled_requests = Mock(return_value=None) def handle_put(request): attr_name = request.path[1] child.handled_requests.put(attr_name, request.value) return [request.return_response()] def handle_post(request): method_name = request.path[1] child.handled_requests.post(method_name, **request.parameters) return [request.return_response()] child._handle_put = handle_put child._handle_post = handle_post return child
def instantiate(self, substitutions, *args): """Keep recursing down from base using dotted name, then call it with self.params and args Args: substitutions (dict): Substitutions to make to self.param_dict *args: Any other args to pass to the callable Returns: object: The found object called with (*args, map_from_d) E.g. if ob is malcolm.parts, and name is "ca.CADoublePart", then the object will be malcolm.parts.ca.CADoublePart """ param_dict = self.substitute_params(substitutions) pkg, ident = self.name.rsplit(".", 1) pkg = "malcolm.modules.%s" % pkg try: ob = importlib.import_module(pkg) except ImportError: raise ImportError("%s:%d:\nCan't import %r" % (self.filename, self.lineno, pkg)) try: ob = getattr(ob, ident) except AttributeError: raise ImportError("%s:%d:\nPackage %r has no ident %r" % (self.filename, self.lineno, pkg, ident)) try: ret = call_with_params(ob, *args, **param_dict) except YamlError as e: raise YamlError("%s:%d:\n%s" % (self.filename, self.lineno, e)) else: return ret
def setUp(self): self.o = call_with_params(Float64Part, name="fp", description="desc", initialValue=2.3, writeable=True, widget="textinput") self.setter = list(self.o.create_attribute_models())[0][2]
def setUp(self): self.o = call_with_params(ChoicePart, name="cp", description="desc", choices=["a", "b"], initialValue="a", writeable=True) self.setter = list(self.o.create_attribute_models())[0][2]
def test_proxy_block(self): process = Mock() controller = call_with_params( proxy_block, process, comms="comms_mri", mri="my_mri", publish=True) process.add_controller.assert_called_once_with( "my_mri", controller, True) process.get_controller.assert_called_once_with("comms_mri") assert controller.client_comms == process.get_controller.return_value
def setUp(self): self.process = Process("proc") self.o = call_with_params(MQTTServerComms, self.process, (), mri="mri", block="block", attribute="attribute", topic_prefix="prefix")
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()
def _make_group(self, attr_name): if attr_name not in self.parts: part = call_with_params(GroupPart, name=attr_name, description="All %s attributes" % attr_name) self._add_part(attr_name, part) group_tag = group(attr_name) return group_tag
def setUp(self): self.o = call_with_params(LabelPart, initialValue="My label", group="mygroup") self.p = Process("proc") self.c = Controller(self.p, "mri", [self.o]) self.p.add_controller("mri", self.c) self.p.start() self.b = self.c.block_view()
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 = call_with_params(ReframePluginPart, name="m", mri="mri") list(self.o.create_attribute_models()) self.process.start()
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.o = call_with_params(HDFWriterPart, name="m", mri="BLOCK-HDF5") list(self.o.create_attribute_models()) self.process.start()
def create_part(self, params=None): if params is None: params = dict( name="mname", description="desc", pv="pv", ) p = call_with_params(CAActionPart, **params) self.yielded = list(p.create_method_models()) return p
def setUp(self): self.mp_q = multiprocessing.Queue() self.mp = multiprocessing.Process(target=p1, args=(self.mp_q, )) self.mp.start() from malcolm.core import Process, call_with_params from malcolm.blocks.pva import pva_client_block self.process2 = Process("proc2") self.client = call_with_params(pva_client_block, self.process2, mri="client") self.process2.start()