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))
