def testMeta(parameters): name = "combined" label = "Linear Combination" unit = "a.u" aggregator = linear sweep_values = combine(*parameters, name=name, label=label, unit=unit, aggregator=aggregator) snap = sweep_values.snapshot() out = OrderedDict() out['__class__'] = full_class(sweep_values) out["unit"] = unit out["label"] = label out["full_name"] = name out["aggregator"] = repr(linear) for param in sweep_values.parameters: out[param.full_name] = {} assert out == snap
def snapshot_base(self, update=False): """ State of the instrument as a JSON-compatible dict. Args: update (bool): If True, update the state by querying the instrument. If False, just use the latest values in memory. Returns: dict: base snapshot """ snap = {'parameters': dict((name, param.snapshot(update=update)) for name, param in self.parameters.items()), 'functions': dict((name, func.snapshot(update=update)) for name, func in self.functions.items()), '__class__': full_class(self), } for attr in set(self._meta_attrs): if hasattr(self, attr): snap[attr] = getattr(self, attr) return snap
def snapshot_base(self, update: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None): """ State of the loop as a JSON-compatible dict (everything that the custom JSON encoder class :class:'qcodes.utils.helpers.NumpyJSONEncoder' supports). Args: update: If True, update the state by querying the underlying sweep_values and actions. If None only update state if known to be invalid. If False, just use the latest values in memory. params_to_skip_update: Unused in this implementation. Returns: dict: base snapshot """ return { '__class__': full_class(self), 'sweep_values': self.sweep_values.snapshot(update=update), 'delay': self.delay, 'then_actions': _actions_snapshot(self.then_actions, update) }
def test_full_class(self): self.assertEqual(full_class(self.j), 'json.encoder.JSONEncoder')
def snapshot_base(self, update: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None): return { '__class__': full_class(self), 'actions': _actions_snapshot(self._dummyLoop.actions, update) }
def snapshot_base(self, update=False): return { '__class__': full_class(self), 'actions': _actions_snapshot(self._dummyLoop.actions, update) }
def snapshot_base( self, update: Optional[bool] = False, params_to_skip_update: Optional[Sequence[str]] = None ) -> Dict[Any, Any]: """ State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class :class:`qcodes.utils.helpers.NumpyJSONEncoder` supports). Args: update: If ``True``, update the state by querying the instrument. If None update the state if known to be invalid. If ``False``, just use the latest values in memory and never update state. params_to_skip_update: List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac). If you want to skip the update of certain parameters in all snapshots, use the ``snapshot_get`` attribute of those parameters instead. Returns: dict: base snapshot """ if params_to_skip_update is None: params_to_skip_update = [] snap: Dict[str, Any] = { "functions": { name: func.snapshot(update=update) for name, func in self.functions.items() }, "submodules": { name: subm.snapshot(update=update) for name, subm in self.submodules.items() }, "__class__": full_class(self) } snap['parameters'] = {} for name, param in self.parameters.items(): if param.snapshot_exclude: continue if params_to_skip_update and name in params_to_skip_update: update_par: Optional[bool] = False else: update_par = update try: snap['parameters'][name] = param.snapshot(update=update_par) except: # really log this twice. Once verbose for the UI and once # at lower level with more info for file based loggers self.log.warning(f"Snapshot: Could not update " f"parameter: {name}") self.log.info(f"Details for Snapshot:", exc_info=True) snap['parameters'][name] = param.snapshot(update=False) for attr in set(self._meta_attrs): if hasattr(self, attr): snap[attr] = getattr(self, attr) return snap
def snapshot_base(self, update: bool=False, params_to_skip_update: Sequence[str]=None, skip_parameters: Sequence[str] = (), skip_parameter_nodes: Sequence[str] = ()): """ State of the instrument as a JSON-compatible dict. Args: update (bool): If True, update the state by querying the instrument. If False, just use the latest values in memory. params_to_skip_update: List of parameter names that will be skipped in update even if update is True. This is useful if you have parameters that are slow to update but can be updated in a different way (as in the qdac) skip_parameters: Names of parameters to skip from snapshot skip_parameter_nodes: Names of parameter nodes to skip from snapshot Returns: dict: base snapshot """ if self.simplify_snapshot: snap = {"__class__": full_class(self)} if self.functions: snap["functions"] = {name: func.snapshot(update=update) for name, func in self.functions.items()} if self.submodules: snap["submodules"] = {name: subm.snapshot(update=update) for name, subm in self.submodules.items()} for parameter_name, parameter in self.parameters.items(): if parameter_name in skip_parameters: continue parameter_snapshot = parameter.snapshot() if 'unit' in parameter_snapshot: parameter_name = f'{parameter_name} ({parameter_snapshot["unit"]})' if parameter._snapshot_value: snap[parameter_name] = parameter_snapshot['value'] else: snap[parameter_name] = parameter_snapshot for parameter_node_name, parameter_node in self.parameter_nodes.items(): if parameter_node_name in skip_parameter_nodes: continue snap[parameter_node_name] = parameter_node.snapshot() else: snap = { "functions": {name: func.snapshot(update=update) for name, func in self.functions.items()}, "submodules": {name: subm.snapshot(update=update) for name, subm in self.submodules.items()}, "__class__": full_class(self), "parameters": {}, "parameter_nodes": { name: node.snapshot() for name, node in self.parameter_nodes.items() if name not in skip_parameter_nodes } } for name, param in self.parameters.items(): if name in skip_parameters: continue update = update if params_to_skip_update and name in params_to_skip_update: update = False try: snap['parameters'][name] = param.snapshot( update=update, simplify=self.simplify_snapshot) except: logger.debug(f"Snapshot: Could not update parameter: {name}") snap['parameters'][name] = param.snapshot( update=False, simplify=self.simplify_snapshot) for attr in set(self._meta_attrs): if hasattr(self, attr): snap[attr] = getattr(self, attr) return snap
def test_full_class(): j = json.JSONEncoder() assert full_class(j) == 'json.encoder.JSONEncoder'