def create_tags(self): tags = [] if self.params.widget: tags.append(widget(self.params.widget)) if self.params.config: tags.append(config()) return tags
def create_attribute_models(self): for data in super(RunnableController, self).create_attribute_models(): yield data # Create sometimes writeable attribute for the current completed scan # step completed_steps_meta = NumberMeta( "int32", "Readback of number of scan steps", tags=[widget("textinput")]) completed_steps_meta.set_writeable_in(ss.PAUSED, ss.ARMED) self.completed_steps = completed_steps_meta.create_attribute_model(0) yield "completedSteps", self.completed_steps, self.set_completed_steps # Create read-only attribute for the number of configured scan steps configured_steps_meta = NumberMeta( "int32", "Number of steps currently configured", tags=[widget("textupdate")]) self.configured_steps = configured_steps_meta.create_attribute_model(0) yield "configuredSteps", self.configured_steps, None # Create read-only attribute for the total number scan steps total_steps_meta = NumberMeta( "int32", "Readback of number of scan steps", tags=[widget("textupdate")]) self.total_steps = total_steps_meta.create_attribute_model(0) yield "totalSteps", self.total_steps, None # Create sometimes writeable attribute for the default axis names axes_to_move_meta = StringArrayMeta( "Default axis names to scan for configure()", tags=[widget("table"), config()]) axes_to_move_meta.set_writeable_in(ss.READY) self.axes_to_move = axes_to_move_meta.create_attribute_model( self.params.axesToMove) yield "axesToMove", self.axes_to_move, self.set_axes_to_move
def update_part_exportable(self, response): # Get a child context to check if we have a config field child = self.child_controller.block_view() spawned = [] if response.value: new_fields = response.value else: new_fields = [] # Remove any existing subscription that is not in the new fields for subscribe in self.config_subscriptions.values(): attr_name = subscribe.path[-2] if attr_name not in new_fields: unsubscribe = Unsubscribe(subscribe.id, subscribe.callback) spawned.append( self.child_controller.handle_request(unsubscribe)) self.port_infos.pop(attr_name, None) # Add a subscription to any new field existing_fields = set(s.path[-2] for s in self.config_subscriptions.values()) for field in set(new_fields) - existing_fields: attr = getattr(child, field) if isinstance(attr, Attribute): for tag in attr.meta.tags: match = port_tag_re.match(tag) if match: d, type, extra = match.groups() self.port_infos[field] = PortInfo(name=field, value=attr.value, direction=d, type=type, extra=extra) if isinstance(attr, Attribute) and config() in attr.meta.tags: if self.config_subscriptions: new_id = max(self.config_subscriptions) + 1 else: new_id = 1 subscribe = Subscribe(id=new_id, path=[self.params.mri, field, "value"], callback=self.update_part_modified) self.config_subscriptions[new_id] = subscribe # Signal that any change we get is a difference if field not in self.saved_structure: self.saved_structure[field] = None spawned.append(self.child_controller.handle_request(subscribe)) # Wait for the first update to come in for s in spawned: s.wait() # Put data on the queue, so if spawns are handled out of order we # still get the most up to date data port_infos = [ self.port_infos[f] for f in new_fields if f in self.port_infos ] self.exportable_update_queue.put((new_fields, port_infos)) self.spawn(self._update_part_exportable).wait()
def __init__(self, process, attr_name): params = Part.MethodMeta.prepare_input_map(name=attr_name) super(PandABoxGroupPart, self).__init__(process, params) self.attr_name = attr_name tags = [widget("group"), config()] self.meta = ChoiceMeta("All %s attributes" % self.attr_name, choices=["expanded", "collapsed"], tags=tags, label=self.attr_name.title())
def _make_field_part(self, field_name, meta, writeable, initial_value=None): if writeable: meta.set_tags(meta.tags + (config(), )) part = PandABlocksFieldPart(self.client, meta, self.block_name, field_name, writeable, initial_value) self._add_part(field_name, part)
def _make_table(self, field_name, field_data): group_tag = self._make_group("parameters") tags = [widget("table"), group_tag, config()] meta = TableMeta(field_data.description, tags) part = PandABlocksTablePart(self.client, meta, self.block_name, field_name, writeable=True) self._add_part(field_name, part)
def create_tags(self): tags = [] if self.params.widget: tags.append(widget(self.params.widget)) if self.params.config and self.is_writeable(): # If we have a writeable func we can be a config param tags.append(config()) if self.params.group: # If we have a group then add the tag tags.append(group(self.params.group)) return tags
def create_attribute_models(self): for data in super(ExposureDetectorDriverPart, self).create_attribute_models(): yield data # Create writeable attribute for how long we should allow for detector # read out meta = NumberMeta("float64", "Time taken to readout detector", tags=[widget("textinput"), config()]) self.readout_time = meta.create_attribute_model( self.params.readoutTime) yield "readoutTime", self.readout_time, self.readout_time.set_value
def create_attribute_models(self): for data in super(PmacTrajectoryPart, self).create_attribute_models(): yield data # Create writeable attribute for the minimum time to leave when there # is a gap between frames meta = NumberMeta("float64", "Min time for any gaps between frames", tags=[widget("textinput"), config()]) self.min_turnaround = meta.create_attribute_model( self.params.minTurnaround) yield "minTurnaround", self.min_turnaround, \ self.min_turnaround.set_value
def create_attribute_models(self): for data in super(ManagerController, self).create_attribute_models(): yield data assert os.path.isdir(self.params.configDir), \ "%s is not a directory" % self.params.configDir if not os.path.isdir(os.path.join(self.params.configDir, ".git")): # Try and make it a git repo, don't care if it fails self._run_git_cmd("init") self._run_git_cmd("commit", "--allow-empty", "-m", "Created repo") # Create writeable attribute table for the layout info we need elements = OrderedDict() elements["name"] = StringArrayMeta("Name of layout part") elements["mri"] = StringArrayMeta("Malcolm full name of child block") elements["x"] = NumberArrayMeta( "float64", "X Coordinate of child block") elements["y"] = NumberArrayMeta( "float64", "Y Coordinate of child block") elements["visible"] = BooleanArrayMeta("Whether child block is visible") layout_table_meta = TableMeta( "Layout of child blocks", elements=elements, tags=[widget("flowgraph")]) layout_table_meta.set_writeable_in(ss.READY) self.layout = layout_table_meta.create_attribute_model() yield "layout", self.layout, self.set_layout # Create writeable attribute for loading an existing layout design_meta = ChoiceMeta( "Design name to load", tags=[config(), widget("combo")]) design_meta.set_writeable_in(ss.READY) self.design = design_meta.create_attribute_model() yield "design", self.design, self.set_design # Create writeable attribute table for the exported fields elements = OrderedDict() elements["name"] = ChoiceArrayMeta("Name of exported block.field") elements["exportName"] = StringArrayMeta( "Name of the field within current block") exports_table_meta = TableMeta( "Exported fields of child blocks", tags=[widget("table")], elements=elements) exports_table_meta.set_writeable_in(ss.READY) self.exports = exports_table_meta.create_attribute_model() yield "exports", self.exports, self.set_exports # Create read-only indicator for when things are modified modified_meta = BooleanMeta( "Whether the design is modified", tags=[widget("led")]) self.modified = modified_meta.create_attribute_model() yield "modified", self.modified, None
def create_attribute_models(self): # Create writeable attribute for current counter value meta = NumberMeta("float64", "A counter", tags=[config()]) self.counter = meta.create_attribute_model() yield "counter", self.counter, self.counter.set_value