def setup(self, registrar: PartRegistrar) -> None:
super().setup(registrar)
# Hooks
registrar.hook(hooks.PreRunHook, self.on_pre_run)
registrar.hook(
(hooks.PauseHook, hooks.AbortHook, hooks.PostRunReadyHook),
self.on_reset)
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:
super().setup(registrar)
# Hooks
registrar.hook((builtin.hooks.InitHook, builtin.hooks.ResetHook),
self.reconnect)
# Methods
self.method = registrar.add_method_model(self.caput, self.name,
self.description)
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:
super().setup(registrar)
# Add methods
registrar.add_method_model(self.servo_frequency,
"servoFrequency",
needs_context=True)
# Hooks
registrar.hook(scanning.hooks.ReportStatusHook, self.report_status)
def setup(self, registrar: PartRegistrar) -> None:
super().setup(registrar)
# Add methods
registrar.add_method_model(self.move,
"moveCS%d" % self.cs,
needs_context=True)
# Hooks
registrar.hook(scanning.hooks.ReportStatusHook, self.report_status)
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:
super().setup(registrar)
# Hooks
registrar.hook(scanning.hooks.ConfigureHook, self.on_configure)
registrar.hook(scanning.hooks.SeekHook, self.on_seek)
registrar.hook(scanning.hooks.PostRunArmedHook, self.on_post_run_armed)
registrar.hook(scanning.hooks.RunHook, self.on_run)
registrar.hook((scanning.hooks.AbortHook, scanning.hooks.PauseHook),
self.on_abort)
def setup(self, registrar: PartRegistrar) -> None:
super().setup(registrar)
# Hooks
registrar.hook(InitHook, self.on_init)
registrar.hook(HaltHook, self.on_halt)
registrar.hook(LayoutHook, self.on_layout)
registrar.hook(LoadHook, self.on_load)
registrar.hook(SaveHook, self.on_save)
registrar.hook(DisableHook, self.on_disable)
registrar.hook(ResetHook, self.on_reset)
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(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)
# 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.AbortHook, builtin.hooks.ResetHook),
self.on_reset)
# 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:
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) -> None:
super().setup(registrar)
# Hooks
registrar.hook(scanning.hooks.ReportStatusHook, self.on_report_status)
registrar.hook(scanning.hooks.ConfigureHook, self.on_configure)
registrar.hook(scanning.hooks.PostConfigureHook,
self.on_post_configure)
registrar.hook(scanning.hooks.ValidateHook, self.on_validate)
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)
# Hooks
registrar.hook(scanning.hooks.ValidateHook, self.on_validate)
registrar.hook(scanning.hooks.PreConfigureHook, self.reload)
registrar.hook(
(
scanning.hooks.ConfigureHook,
scanning.hooks.PostRunArmedHook,
scanning.hooks.SeekHook,
),
self.on_configure,
)
registrar.hook(scanning.hooks.RunHook, self.on_run)
registrar.hook((scanning.hooks.AbortHook, scanning.hooks.PauseHook),
self.on_abort)
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)
# 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:
super(KinematicsSavuPart, self).setup(registrar)
# Tell the controller to expose some extra configure parameters
registrar.report(scanning.hooks.ConfigureHook.create_info(self.on_configure))
# Hooks
registrar.hook(scanning.hooks.ConfigureHook, self.on_configure)
registrar.hook(scanning.hooks.PostConfigureHook, self.on_post_configure)
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:
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)
# 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.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:
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:
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:
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:
super().setup(registrar)
# Hooks
registrar.hook(scanning.hooks.PreConfigureHook, self.reload)
registrar.hook(
(
scanning.hooks.ConfigureHook,
scanning.hooks.PostRunArmedHook,
scanning.hooks.SeekHook,
),
self.on_configure,
)
registrar.hook(scanning.hooks.RunHook, self.on_run)
# 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)
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().setup(registrar)
# Hooks
registrar.hook(scanning.hooks.ReportStatusHook, self.on_report_status)
registrar.hook(
(
scanning.hooks.ConfigureHook,
scanning.hooks.SeekHook,
scanning.hooks.PostRunArmedHook,
),
self.on_configure,
)
registrar.hook(scanning.hooks.RunHook, self.on_run)
