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)