def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model("minTurnaround", self.gap, self.gap.set_value) registrar.add_attribute_model("minTurnaroundInterval", self.interval, self.interval.set_value) # Hooks registrar.hook(ReportStatusHook, self.on_report_status)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Hooks registrar.hook(scanning.hooks.ReportStatusHook, self.on_report_status) registrar.hook(scanning.hooks.ValidateHook, self.on_validate) registrar.hook( scanning.hooks.ConfigureHook, self.on_configure, self.configure_args_with_exposure, ) registrar.hook( scanning.hooks.SeekHook, self.on_seek, self.configure_args_with_exposure, ) registrar.hook(scanning.hooks.RunHook, self.on_run) registrar.hook(scanning.hooks.PostRunArmedHook, self.on_post_run_armed) registrar.hook((scanning.hooks.PauseHook, scanning.hooks.AbortHook), self.on_abort) # Attributes registrar.add_attribute_model("attributesToCapture", self.extra_attributes, self.set_extra_attributes) # Tell the controller to pass "exposure" and "frames_per_step" to configure info = scanning.infos.ConfigureParamsInfo( metas=dict(frames_per_step=NumberMeta.from_annotype( ADetectorFramesPerStep, writeable=False), ), required=[], defaults=dict(frames_per_step=1), ) registrar.report(info)
def setup(self, registrar: PartRegistrar) -> None: self.my_attribute = StringMeta(description="MyString").create_attribute_model( "hello_block" ) registrar.add_attribute_model( "myAttribute", self.my_attribute, self.my_attribute.set_value ) registrar.add_method_model(self.method)
def setup(self, registrar: PartRegistrar) -> None: self.datasets = TableMeta.from_table( DatasetTable, "Datasets produced in HDF file").create_attribute_model() registrar.add_attribute_model("datasets", self.datasets) # Hooks registrar.hook(PostConfigureHook, self.on_post_configure) registrar.hook(builtin.hooks.ResetHook, self.on_reset)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) attr_name = snake_to_camel(self.field_name.replace(".", "_")) writeable_func: Optional[Callable] if self.meta.writeable: writeable_func = self.set_field else: writeable_func = None registrar.add_attribute_model(attr_name, self.attr, writeable_func)
def setup(self, registrar: PartRegistrar) -> None: self.caa.setup(registrar, self.name, self.register_hooked) # Add 9 compound motor attributes for k in CS_AXIS_NAMES + ["I"]: # Note no widget tag as we don't want it on the properties pane, # just the layout view v = StringMeta( f"Axis Source Port value {k}").create_attribute_model() self.axis_attrs[k] = v registrar.add_attribute_model(k.lower(), v)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) registrar.add_attribute_model( "targetSamplesPerFrame", self.targetSamplesPerFrame, self.targetSamplesPerFrame.set_value, ) registrar.hook(scanning.hooks.PostRunReadyHook, self.on_post_run_ready) registrar.hook(scanning.hooks.PostRunArmedHook, self.on_post_run_armed) registrar.hook(scanning.hooks.PostConfigureHook, self.on_post_configure)
def setup(self, registrar: PartRegistrar) -> None: super(PortsPart, self).setup(registrar) attr = StringMeta(tags=[Port.INT32.sink_port_tag(""), config_tag(1)]).create_attribute_model() registrar.add_attribute_model("sinkportConnector", attr, attr.set_value) attr = StringMeta(tags=[Port.INT32.source_port_tag(self.name) ]).create_attribute_model() registrar.add_attribute_model("sourceportConnector", attr, attr.set_value)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Attributes registrar.add_attribute_model("exposure", self.exposure) # Tell the controller to pass "exposure" to configure info = scanning.infos.ConfigureParamsInfo( metas=dict(exposure=NumberMeta.from_annotype( scanning.hooks.AExposure, writeable=True)), required=[], defaults=dict(exposure=0.0), ) registrar.report(info)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Add methods registrar.add_method_model( self.write_profile, "writeProfile", needs_context=True ) registrar.add_method_model( self.execute_profile, "executeProfile", needs_context=True ) registrar.add_method_model( self.abort_profile, "abortProfile", needs_context=True ) # Add Attributes registrar.add_attribute_model("pointsScanned", self.points_scanned)
def setup(self, registrar: PartRegistrar) -> None: self.mocks = {} self.units = {} for suffix in ["step", "delay", "width", "pulses"]: # Add an attribute that will be set attr = NumberMeta("float64").create_attribute_model() mock = MagicMock(side_effect=attr.set_value) registrar.add_attribute_model(suffix, attr, mock) self.mocks[suffix] = mock if suffix != "pulses": # Add a units attribute that will be read units_attr = StringMeta().create_attribute_model("s") registrar.add_attribute_model(suffix + "Units", units_attr) self.units[suffix] = units_attr
def setup( self, registrar: PartRegistrar, name: str, register_hooked: Register, writeable_func: Callable[[Any], None] = None, ) -> None: if self.writeable: if writeable_func is None: writeable_func = self.caput else: writeable_func = None registrar.add_attribute_model(name, self.attr, writeable_func) register_hooked(builtin.hooks.DisableHook, self.disconnect) register_hooked((builtin.hooks.InitHook, builtin.hooks.ResetHook), self.reconnect)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) registrar.add_attribute_model("dlsVersion", self.dls_ver_pv.attr) registrar.add_attribute_model("dir1", self.dir1_pv.attr) registrar.add_attribute_model("dir2", self.dir2_pv.attr) registrar.add_attribute_model("autosaveStatus", self.autosave_status_pv.attr) registrar.add_attribute_model("dependencies", self.dependencies) self.register_hooked(hooks.DisableHook, self.disconnect) self.register_hooked((hooks.InitHook, hooks.ResetHook), self.reconnect)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Validate hook for exposure time registrar.hook(scanning.hooks.ValidateHook, self.on_validate) # Attributes registrar.add_attribute_model("exposure", self.exposure) # Tell the controller to pass "exposure" and "frames_per_step" to configure info = scanning.infos.ConfigureParamsInfo( metas=dict( exposure=NumberMeta.from_annotype(scanning.hooks.AExposure, writeable=True), frames_per_step=NumberMeta.from_annotype(AFramesPerStep, writeable=False), ), required=[], defaults=dict(exposure=0.0, frames_per_step=1), ) registrar.report(info)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Hooks registrar.hook(scanning.hooks.ConfigureHook, self.on_configure) registrar.hook( (scanning.hooks.PostRunArmedHook, scanning.hooks.SeekHook), self.on_seek) registrar.hook(scanning.hooks.RunHook, self.on_run) registrar.hook(scanning.hooks.PostRunReadyHook, self.on_post_run_ready) registrar.hook(scanning.hooks.AbortHook, self.on_abort) # Attributes registrar.add_attribute_model( "writeAllNdAttributes", self.write_all_nd_attributes, self.write_all_nd_attributes.set_value, ) # Tell the controller to expose some extra configure parameters registrar.report( scanning.hooks.ConfigureHook.create_info(self.on_configure))
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Add some Attribute and Methods to the Block self.counter = NumberMeta( "float64", "The current value of the counter", tags=[config_tag(), Widget.TEXTINPUT.tag()], ).create_attribute_model() registrar.add_attribute_model("counter", self.counter, self.counter.set_value) self.delta = NumberMeta( "float64", "The amount to increment() by", tags=[config_tag(), Widget.TEXTINPUT.tag()], ).create_attribute_model(initial_value=1) registrar.add_attribute_model("delta", self.delta, self.delta.set_value) registrar.add_method_model(self.zero) registrar.add_method_model(self.increment)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Hooks registrar.hook(scanning.hooks.ReportStatusHook, self.on_report_status) registrar.hook( ( scanning.hooks.ConfigureHook, scanning.hooks.PostRunArmedHook, scanning.hooks.SeekHook, ), self.on_configure, self.configure_args_with_exposure, ) registrar.hook(scanning.hooks.RunHook, self.on_run) registrar.hook( (scanning.hooks.PauseHook, scanning.hooks.AbortHook), self.on_abort ) # Attributes registrar.add_attribute_model( "attributesToCapture", self.extra_attributes, self.set_extra_attributes )
def setup(self, registrar: PartRegistrar) -> None: self.bits = TableMeta.from_table( self.bits_table_cls, "Current values and capture status of Bit fields", writeable=[ x for x in self.bits_table_cls.call_types if x not in ("name", "value") ], extra_tags=[config_tag()], ).create_attribute_model() self.positions = TableMeta.from_table( self.positions_table_cls, "Current values, scaling, and capture status of Position fields", writeable=[ x for x in self.positions_table_cls.call_types if x not in ("name", "value") ], extra_tags=[config_tag()], ).create_attribute_model() registrar.add_attribute_model("bits", self.bits, self.set_bits) registrar.add_attribute_model("positions", self.positions, self.set_positions)
def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model("pmac", self.pmac_attr) registrar.add_attribute_model("axisNumber", self.axis_num_attr) registrar.add_attribute_model("cs", self.cs_attr, self.caput) # Hooks registrar.hook(builtin.hooks.DisableHook, self.disconnect) registrar.hook((builtin.hooks.InitHook, builtin.hooks.ResetHook), self.reconnect)
def setup(self, registrar: PartRegistrar) -> None: pos_table = DatasetPositionsTable( name=["COUNTER1.VALUE", "INENC1.VAL", "INENC2.VAL"], value=[0.0] * 3, units=[""] * 3, # NOTE: x inverted from MRES below to simulate inversion of # encoder in the geobrick layer scale=[1.0, -0.001, 0.001], offset=[0.0, 0.0, 0.0], capture=[PositionCapture.MIN_MAX_MEAN] * 3, datasetName=["I0", "x", "y"], datasetType=[ AttributeDatasetType.MONITOR, AttributeDatasetType.POSITION, AttributeDatasetType.POSITION, ], ) attr = TableMeta.from_table( DatasetPositionsTable, "Sequencer Table", writeable=list(SequencerTable.call_types), ).create_attribute_model(pos_table) registrar.add_attribute_model("positions", attr)
def setup(self, registrar: PartRegistrar) -> None: attr = TableMeta.from_table( SequencerTable, "Sequencer Table", writeable=list( SequencerTable.call_types)).create_attribute_model() self.table_set = MagicMock(side_effect=attr.set_value) registrar.add_attribute_model("table", attr, self.table_set) for suff, val in (("a", "INENC1.VAL"), ("b", "INENC2.VAL"), ("c", "ZERO")): attr = StringMeta("Input").create_attribute_model(val) registrar.add_attribute_model(f"pos{suff}", attr) attr = StringMeta("Input").create_attribute_model("ZERO") registrar.add_attribute_model("bita", attr) attr = BooleanMeta("Active", (), True).create_attribute_model(False) registrar.add_attribute_model("active", attr, attr.set_value) attr = NumberMeta("int16", "repeats", writeable=True).create_attribute_model(1) registrar.add_attribute_model("repeats", attr, writeable_func=attr.set_value)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Hooks registrar.hook(scanning.hooks.ReportStatusHook, self.on_report_status) # Attributes registrar.add_attribute_model( "windowsDriveLetter", self.windows_drive_letter, self.windows_drive_letter.set_value, ) registrar.add_attribute_model("pathPrefix", self.path_prefix, self.path_prefix.set_value) registrar.add_attribute_model("networkPrefix", self.network_prefix, self.network_prefix.set_value)
def setup(self, registrar: PartRegistrar) -> None: attr = TableMeta.from_table( SequencerTable, "Sequencer Table", writeable=list( SequencerTable.call_types)).create_attribute_model() self.table_set = MagicMock(side_effect=attr.set_value) registrar.add_attribute_model("table", attr, self.table_set) for suff, val in (("a", "INENC1.VAL"), ("b", "INENC2.VAL"), ("c", "ZERO")): attr = StringMeta("Input").create_attribute_model(val) registrar.add_attribute_model("pos%s" % suff, attr) attr = StringMeta("Input").create_attribute_model("ZERO") registrar.add_attribute_model("bita", attr)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Hooks registrar.hook(ReportStatusHook, self.on_report_status) registrar.hook(ValidateHook, self.on_validate) registrar.hook(ConfigureHook, self.on_configure) # Attributes registrar.add_attribute_model("readoutTime", self.readout_time) registrar.add_attribute_model("frequencyAccuracy", self.frequency_accuracy) registrar.add_attribute_model("exposure", self.exposure) # Tell the controller to expose some extra configure parameters registrar.report(ConfigureHook.create_info(self.on_configure)) # Tell the controller to expose some extra validate parameters registrar.report(ConfigureHook.create_info(self.on_validate))
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) # Register attributes registrar.add_attribute_model("runnerState", self.runner_state, self.runner_state.set_value) registrar.add_attribute_model( "runnerStatusMessage", self.runner_status_message, self.runner_status_message.set_value, ) registrar.add_attribute_model("scanFile", self.scan_file, self.scan_file.set_value) registrar.add_attribute_model("scansConfigured", self.scans_configured, self.scans_configured.set_value) registrar.add_attribute_model("currentScanSet", self.current_scan_set, self.current_scan_set.set_value) registrar.add_attribute_model("scansCompleted", self.scans_completed, self.scans_completed.set_value) registrar.add_attribute_model("scanSuccesses", self.scan_successes, self.scan_successes.set_value) registrar.add_attribute_model("scanFailures", self.scan_failures, self.scan_failures.set_value) registrar.add_attribute_model("outputDirectory", self.output_directory, self.output_directory.set_value) # Methods registrar.add_method_model(self.loadFile) registrar.add_method_model(self.run, needs_context=True) registrar.add_method_model(self.abort, needs_context=True)
def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model(self.name, self.attr, self.attr.set_value)
def setup(self, registrar: PartRegistrar) -> None: super().setup(registrar) registrar.add_attribute_model(self.name, self.attr, self.set_label) self._report()
def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model(self.name, self.attr) # Hooks registrar.hook(builtin.hooks.DisableHook, self.disconnect) registrar.hook((builtin.hooks.InitHook, builtin.hooks.ResetHook), self.reconnect)
def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model(self.name, self.attr, self.writeable_func)
def setup(self, registrar: PartRegistrar) -> None: registrar.add_attribute_model(self.name, self.attr, self.attr.set_value) # Tell the controller to expose some extra configure parameters registrar.report(ConfigureHook.create_info(self.configure))