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)
attr = NumberMeta("int16", "prescale",
writeable=True).create_attribute_model(0)
registrar.add_attribute_model("prescale",
attr,
writeable_func=attr.set_value)
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 __init__(self, name):
# type: (APartName) -> None
super(DatasetTablePart, self).__init__(name)
self.datasets = TableMeta.from_table(
DatasetTable,
"Datasets produced in HDF file").create_attribute_model()
self.register_hooked(scanning.hooks.PostConfigureHook,
self.post_configure)
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:
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 __init__(
self,
name: APartName,
mri: AMri,
soft_trigger_modes: USoftTriggerModes = None,
multiple_image_mode: AMultipleImageMode = "Multiple",
main_dataset_useful: AMainDatasetUseful = True,
runs_on_windows: APartRunsOnWindows = False,
required_version: AVersionRequirement = None,
min_acquire_period: AMinAcquirePeriod = 0.0,
) -> None:
super().__init__(name, mri)
self.required_version = required_version
self.min_acquire_period = min_acquire_period
self.soft_trigger_modes = soft_trigger_modes
self.multiple_image_mode = multiple_image_mode
self.is_hardware_triggered = True
self.main_dataset_useful = main_dataset_useful
self.attributes_filename = ""
self.extra_attributes = TableMeta.from_table(
ExtraAttributesTable,
"Extra attributes to be added to the dataset",
writeable=[
"name",
"pv",
"description",
"sourceId",
"sourceType",
"dataType",
"datasetType",
],
extra_tags=[config_tag()],
).create_attribute_model()
self.runs_on_windows = runs_on_windows
# How long to wait between frame updates before error
self.frame_timeout = 0.0
# When arrayCounter gets to here we are done
self.done_when_reaches = 0
# CompletedSteps = arrayCounter + self.uniqueid_offset
self.uniqueid_offset = 0
# A future that completes when detector start calls back
self.start_future: Optional[Future] = None
def __init__(
self,
mri: builtin.controllers.AMri,
hostname: AHostname = "localhost",
port: APort = 8008,
connect_timeout: AConnectTimeout = DEFAULT_TIMEOUT,
) -> None:
super().__init__(mri)
self.hostname = hostname
self.port = port
self.connect_timeout = connect_timeout
self._connected_queue = Queue()
# {new_id: request}
self._request_lookup: Dict[int, Request] = {}
self._next_id = 1
self._conn: Optional[WebSocketClientConnection] = None
# Create read-only attribute for the remotely reachable blocks
self.remote_blocks = TableMeta.from_table(
BlockTable, "Remotely reachable blocks").create_attribute_model()
self.field_registry.add_attribute_model("remoteBlocks",
self.remote_blocks)
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 __init__(
self,
mri: AMri,
config_dir: AConfigDir,
template_designs: ATemplateDesigns = "",
initial_design: AInitialDesign = "",
use_git: AUseGit = True,
description: ADescription = "",
) -> None:
super().__init__(mri=mri, description=description)
assert os.path.isdir(config_dir), "%s is not a directory" % config_dir
self.config_dir = config_dir
self.initial_design = initial_design
self.use_git = use_git
self.template_designs = template_designs
self.git_config: Tuple[str, ...]
if use_git:
if check_git_version("1.7.2"):
self.git_email = os.environ["USER"] + "@" + socket.gethostname(
)
self.git_name = "Malcolm"
self.git_config = (
"-c",
"user.name=%s" % self.git_name,
"-c",
'user.email="%s"' % self.git_email,
)
else:
self.git_config = ()
# last saved layout and exports
self.saved_visibility = None
self.saved_exports = None
# ((name, AttributeModel/MethodModel, setter, needs_context))
self._current_part_fields = ()
self._subscriptions: List[Subscribe] = []
self.port_info: Dict[APartName, List[PortInfo]] = {}
self.part_exportable: Dict[Part, List[AAttributeName]] = {}
# TODO: turn this into "exported attribute modified"
self.context_modified: Dict[Part, Set[str]] = {}
self.part_modified: Dict[Part, PartModifiedInfo] = {}
# The attributes our part has published
self.our_config_attributes: Dict[str, AttributeModel] = {}
# The reportable infos we are listening for
self.info_registry.add_reportable(PartModifiedInfo,
self.update_modified)
# Update queue of exportable fields
self.info_registry.add_reportable(PartExportableInfo,
self.update_exportable)
# Create a port for ourself
self.field_registry.add_attribute_model(
"mri",
StringMeta(
"A port for giving our MRI to things that might use us",
tags=[Port.BLOCK.source_port_tag(self.mri)],
).create_attribute_model(self.mri),
)
# Create a layout table attribute for setting block positions
self.layout = TableMeta.from_table(
LayoutTable,
"Layout of child blocks",
Widget.FLOWGRAPH,
writeable=["x", "y", "visible"],
).create_attribute_model()
self.set_writeable_in(self.layout, ss.READY)
self.field_registry.add_attribute_model("layout", self.layout,
self.set_layout)
# Create a design attribute for loading an existing layout
self.design = ChoiceMeta("Design name to load",
tags=[config_tag(),
Widget.COMBO.tag()
]).create_attribute_model()
self.field_registry.add_attribute_model("design", self.design,
self.set_design)
self.set_writeable_in(self.design, ss.READY)
# Create an export table for mirroring exported fields
self.exports = TableMeta.from_table(
ExportTable,
"Exported fields of child blocks",
writeable=list(ExportTable.call_types),
).create_attribute_model()
# Overwrite the sources meta to be a ChoiceArrayMeta
self.exports.meta.elements["source"] = ChoiceArrayMeta(
"Name of the block.field to export",
writeable=True,
tags=[Widget.COMBO.tag()],
)
self.set_writeable_in(self.exports, ss.READY)
self.field_registry.add_attribute_model("exports", self.exports,
self.set_exports)
# Create read-only indicator for when things are modified
self.modified = BooleanMeta("Whether the design is modified",
tags=[Widget.LED.tag()
]).create_attribute_model()
self.field_registry.add_attribute_model("modified", self.modified)
# Create the save method
self.set_writeable_in(self.field_registry.add_method_model(self.save),
ss.READY)
