def test_monitor_loaded_if_specified(example_station_config):
st = Station(config_file=example_station_config, use_monitor=True)
st.load_instrument('mock_dac')
assert Monitor.running is not None
assert len(Monitor.running._parameters) == 1
assert Monitor.running._parameters[0].name == 'ch1'
Monitor.running.stop()
def test_add_component():
bob = DummyInstrument('bob', gates=['one'])
station = Station()
station.add_component(bob, 'bob')
assert ['bob'] == list(station.components.keys())
assert bob == station.components['bob']
def test_monitor_loaded_by_default_if_in_config(example_station_config):
qcodes.config["station"]['use_monitor'] = True
st = Station(config_file=example_station_config)
st.load_instrument('mock_dac')
assert Monitor.running is not None
assert len(Monitor.running._parameters) == 1
assert Monitor.running._parameters[0].name == 'ch1'
Monitor.running.stop()
def test_close_all_registered_instruments():
names = [f'some_name_{i}' for i in range(10)]
instrs = [Instrument(name=name) for name in names]
st = Station(*instrs)
for name in names:
assert name in Instrument._all_instruments
st.close_all_registered_instruments()
for name in names:
assert name not in Instrument._all_instruments
def test_dynamic_reload_of_file(example_station_config):
st = Station(config_file=example_station_config)
mock_dac = st.load_instrument('mock_dac')
assert 'ch1' in mock_dac.parameters
with open(example_station_config, 'r') as f:
filedata = f.read().replace('ch1', 'gate1')
with open(example_station_config, 'w') as f:
f.write(filedata)
mock_dac = st.load_instrument('mock_dac')
assert 'ch1' not in mock_dac.parameters
assert 'gate1' in mock_dac.parameters
def test_add_component_without_specifying_name():
"""
Test that station looks for 'name' attribute in the component and uses it
"""
bob = DummyInstrument('bob', gates=['one'])
assert hasattr(bob, 'name')
assert 'bob' == bob.name
station = Station()
station.add_component(bob)
assert ['bob'] == list(station.components.keys())
assert bob == station.components['bob']
def __init__(self,
name,
address,
mirrorfactors=[1, 1],
verbose=1,
**kwargs):
logging.debug(__name__ + ' : Initializing instrument')
super().__init__(name, address, **kwargs)
self.station = Station()
self._address = address
self._values = {}
self.verbose = verbose
self._total_cycle_num = 100
self._sampling_frequency = 1000e3
self.visa_handle.baud_rate = 57600
self.set_sampling_frequency(self._sampling_frequency)
self.mirrorfactors = mirrorfactors
# Add parameters
#self.add_parameter('mode',
# set_cmd=functools.partial(self.write_to_serial, 130))
#self.add_parameter('ch1_cycle_num',
# get_cmd=functools.partial(self.ask_from_serial, 1))
#self.add_parameter('ch2_cycle_num',
# get_cmd=functools.partial(self.ask_from_serial, 5))
#self.add_parameter('measurement_done',
# get_cmd=self.get_measurement_done)
#self.add_parameter('total_cycle_num',
# get_cmd=self.get_total_cycle_num,
# set_cmd=self.set_total_cycle_num)
#self.add_parameter('ch1_datapoint_num',
# get_cmd=self.get_ch1_datapoint_num)
#self.add_parameter('ch2_datapoint_num',
# get_cmd=self.get_ch2_datapoint_num)
#self.add_parameter('data',
# get_cmd=self.station.alazar.data.get())
#self.add_parameter('ch1=_data',
# get_cmd=self.channel.data.get())
#self.add_parameter('sampling_frequency',
# get_cmd=self.station.alazar.get_sample_rate,
# set_cmd=self.station.alazar.set_sample_rate)
v = self.visa_handle
# make sure term characters are ignored
logging.debug(__name__ + ' : set termchar settings')
v.set_visa_attribute(visa.constants.VI_ATTR_TERMCHAR_EN, 0)
v.set_visa_attribute(visa.constants.VI_ATTR_ASRL_END_IN, 0)
logging.debug(__name__ + ' : completed initialization')
def setUpClass(cls):
cls.p1 = Parameter('p1', get_cmd=None, set_cmd=None, vals=Numbers(-10, 10))
cls.p2 = Parameter('p2', get_cmd=None, set_cmd=None, vals=Numbers(-10, 10))
cls.p3 = Parameter('p3', get_cmd=None, set_cmd=None, vals=Numbers(-10, 10))
cls.instr = DummyInstrument('dummy_bunny')
cls.p4_crazy = NanReturningParameter('p4_crazy', instrument=cls.instr)
Station()
def test_load_from_db_dataset_moved(meas_with_registered_param, DMM, DAC,
tmp_path):
Station(DAC, DMM)
with meas_with_registered_param.run(
dataset_class=DataSetType.DataSetInMem) as datasaver:
for set_v in np.linspace(0, 25, 10):
DAC.ch1.set(set_v)
get_v = DMM.v1()
datasaver.add_result((DAC.ch1, set_v), (DMM.v1, get_v))
ds = datasaver.dataset
ds.add_metadata("foo", "bar")
ds.export(export_type="netcdf", path=tmp_path)
export_path = ds.export_info.export_paths["nc"]
new_path = str(Path(export_path).parent / "someotherfilename.nc")
shutil.move(export_path, new_path)
with pytest.warns(UserWarning,
match="Could not load raw data for dataset with guid"):
loaded_ds = load_by_id(ds.run_id)
assert isinstance(loaded_ds, DataSetInMem)
assert loaded_ds.snapshot == ds.snapshot
assert loaded_ds.export_info == ds.export_info
assert loaded_ds.metadata == ds.metadata
assert "foo" in loaded_ds.metadata.keys()
assert "export_info" in loaded_ds.metadata.keys()
assert loaded_ds.cache.data() == {}
loaded_ds.set_netcdf_location(new_path)
assert loaded_ds.cache.data().keys() == ds.cache.data().keys()
def test_load_from_db(meas_with_registered_param, DMM, DAC, tmp_path):
Station(DAC, DMM)
with meas_with_registered_param.run(
dataset_class=DataSetType.DataSetInMem) as datasaver:
for set_v in np.linspace(0, 25, 10):
DAC.ch1.set(set_v)
get_v = DMM.v1()
datasaver.add_result((DAC.ch1, set_v), (DMM.v1, get_v))
ds = datasaver.dataset
ds.add_metadata("foo", "bar")
ds.export(export_type="netcdf", path=tmp_path)
ds.add_metadata("metadata_added_after_export", 69)
loaded_ds = load_by_id(ds.run_id)
assert isinstance(loaded_ds, DataSetInMem)
assert loaded_ds.snapshot == ds.snapshot
assert loaded_ds.export_info == ds.export_info
assert loaded_ds.metadata == ds.metadata
assert "foo" in loaded_ds.metadata.keys()
assert "export_info" in loaded_ds.metadata.keys()
assert "metadata_added_after_export" in loaded_ds.metadata.keys()
assert loaded_ds.metadata["metadata_added_after_export"] == 69
compare_datasets(ds, loaded_ds)
def test_station_getitem():
bob = DummyInstrument('bob', gates=['one'])
station = Station(bob)
assert bob == station['bob']
with pytest.raises(KeyError, match='bobby'):
_ = station.components['bobby']
def test_station_config_can_be_loaded_from_snapshot(example_station):
assert station_config_has_been_loaded(example_station)
# ensure that we can correctly dump config which is a subclass of UserDict
configdump = json.dumps(example_station.config, cls=NumpyJSONEncoder)
# as this is now a regular dict we can load it back
loaded_config = json.loads(configdump)
# now lets ensure that we can recreate the
# station from the loaded config
# first we need to get a yaml repr of the data
yaml = YAML()
with StringIO() as output:
yaml.dump(loaded_config, output)
yaml_repr = output.getvalue()
# which we can then reload into the station
new_station = Station(default=False)
new_station.load_config(yaml_repr)
assert example_station.config == new_station.config
def test_station():
bob = DummyInstrument('bob', gates=['one'])
station = Station(bob)
assert ['bob'] == list(station.components.keys())
assert bob == station.components['bob']
assert station == station.default
assert station == Station.default
def test_snapshot():
station = Station()
empty_snapshot = station.snapshot()
assert {'instruments': {},
'parameters': {},
'components': {},
'config': None,
'default_measurement': []
} == empty_snapshot
instrument = DummyInstrument('instrument', gates=['one'])
station.add_component(instrument)
instrument_snapshot = instrument.snapshot()
parameter = Parameter('parameter', label='Label', unit='m')
station.add_component(parameter)
parameter_snapshot = parameter.snapshot()
component = DumyPar('component')
component.metadata['smth'] = 'in the way she moves'
station.add_component(component)
component_snapshot = component.snapshot()
snapshot = station.snapshot()
assert isinstance(snapshot, dict)
assert ['instruments',
'parameters',
'components',
'config',
'default_measurement'
] == list(snapshot.keys())
assert ['instrument'] == list(snapshot['instruments'].keys())
assert instrument_snapshot == snapshot['instruments']['instrument']
assert ['parameter'] == list(snapshot['parameters'].keys())
assert parameter_snapshot == snapshot['parameters']['parameter']
assert ['component'] == list(snapshot['components'].keys())
assert component_snapshot == snapshot['components']['component']
assert [] == snapshot['default_measurement']
def __init__(self,
filename: Optional[str] = None,
station: Optional[Station] = None) -> None:
self.monitor_parameters = {}
if station is None:
station = Station.default or Station()
self.station = station
self.load_file(filename)
def test_station_delegated_attributes():
bob = DummyInstrument('bob', gates=['one'])
station = Station(bob)
assert bob == station.bob
with pytest.raises(AttributeError, match="'Station' object and its "
"delegates have no attribute "
"'bobby'"):
_ = station.bobby
def test_station_after_instrument_is_closed():
"""
Test that station is aware of the fact that its components could be
removed within the lifetime of the station. Here we instantiate an
instrument, add it to a station, then close the instrument, and then
perform an action on the station to ensure that the closed instrument
does not break the work of the station object.
"""
bob = DummyInstrument('bob', gates=['one'])
station = Station(bob)
assert bob == station['bob']
bob.close()
# 'bob' is closed, but it is still part of the station
assert bob == station['bob']
# check that snapshot method executes without exceptions
snapshot = station.snapshot()
# check that 'bob's snapshot is not here (because 'bob' is closed,
# hence it was ignored, and even removed from the station by
# `snapshot_base` method)
assert {
'instruments': {},
'parameters': {},
'components': {},
'config': None,
'default_measurement': []
} == snapshot
# check that 'bob' has been removed from the station
with pytest.raises(KeyError, match='bob'):
_ = station.components['bob']
# check that 'bob' has been removed from the station, again
with pytest.raises(KeyError,
match='Component bob is not part of the '
'station'):
station.remove_component('bob')
def test_loop_writing_2D(self):
# pass
station = Station()
MockPar = MockParabola(name='Loop_writing_test_2D')
station.add_component(MockPar)
loop = Loop(MockPar.x[-100:100:20]).loop(MockPar.y[-50:50:10]).each(
MockPar.skewed_parabola)
data1 = loop.run(name='MockLoop_hdf5_test', formatter=self.formatter)
data2 = DataSet(location=data1.location, formatter=self.formatter)
data2.read()
for key in data2.arrays.keys():
self.checkArraysEqual(data2.arrays[key], data1.arrays[key])
metadata_equal, err_msg = compare_dictionaries(data1.metadata,
data2.metadata,
'original_metadata',
'loaded_metadata')
self.assertTrue(metadata_equal, msg='\n' + err_msg)
self.formatter.close_file(data1)
self.formatter.close_file(data2)
def test_config_validation_failure_on_file():
with pytest.raises(ValidationWarning):
test_config = """
instruments:
mock:
driver: qcodes.tests.instrument_mocks.DummyInstrument
invalid_keyword:
more_errors: 42
"""
with config_file_context(test_config) as filename:
Station(config_file=filename)
def test_station_config_path_resolution(example_station_config):
config = qcodes.config["station"]
# There is no default yaml file present that defines a station
# so we expect the station config not to be loaded.
assert not station_config_has_been_loaded(Station())
path = Path(example_station_config)
config["default_file"] = str(path)
# Now the default file with the station configuration is specified, and
# this file exists, hence we expect the Station to have the station
# configuration loaded upon initialization.
assert station_config_has_been_loaded(Station())
config["default_file"] = path.name
config["default_folder"] = str(path.parent)
# Here the default_file setting contains only the file name, and the
# default_folder contains the path to the folder where this file is
# located, hence we again expect that the station configuration is loaded
# upon station initialization.
assert station_config_has_been_loaded(Station())
config["default_file"] = 'random.yml'
config["default_folder"] = str(path.parent)
# In this case, the station configuration file specified in the qcodes
# config does not exist, hence the initialized station is not expected to
# have station configuration loaded.
assert not station_config_has_been_loaded(Station())
config["default_file"] = str(path)
config["default_folder"] = r'C:\SomeOtherFolder'
# In this case, the default_file setting of the qcodes config contains
# absolute path to the station configuration file, while the default_folder
# setting is set to some non-existent folder.
# In this situation, the value of the default_folder will be ignored,
# but because the file specified in default_file setting exists,
# the station will be initialized with the loaded configuration.
assert station_config_has_been_loaded(Station())
config["default_file"] = None
config["default_folder"] = str(path.parent)
# When qcodes config has only the default_folder setting specified to an
# existing folder, and default_file setting is not specified, then
# passing the name of a station configuration file, that exists in that
# default_folder, as an argument to the Station is expected to result
# in a station with loaded configuration.
assert station_config_has_been_loaded(Station(config_file=path.name))
config["default_file"] = None
config["default_folder"] = None
# In case qcodes config does not have default_file and default_folder
# settings specified, passing an absolute file path as an argument to the
# station is expected to result in a station with loaded configuration.
assert station_config_has_been_loaded(Station(config_file=str(path)))
def __init__(
self,
station: Optional[Station] = None,
filename: str = nt.config["device_config_file"],
) -> None:
self.monitor_parameters: Dict[int, Any] = {}
if station is None:
station = Station.default or Station()
self.station = station
self.filename = filename
self.load_file()
def test_station_config_created_with_multiple_config_files():
test_config1 = f"""
instruments:
mock_dac1:
type: qcodes.tests.instrument_mocks.DummyInstrument
enable_forced_reconnect: true
init:
gates: {{"ch1", "ch2"}}
parameters:
ch1:
monitor: true
"""
test_config2 = f"""
instruments:
mock_dac2:
type: qcodes.tests.instrument_mocks.DummyInstrument
"""
with config_files_context(test_config1, test_config2) as file_list:
assert station_config_has_been_loaded(Station(config_file=file_list))
def test_snapshot_creation_for_types_not_supported_by_builtin_json(experiment):
"""
Test that `Measurement`/`Runner`/`DataSaver` infrastructure
successfully dumps station snapshots in JSON format in cases when the
snapshot contains data of types that are not supported by python builtin
`json` module, for example, numpy scalars.
"""
p1 = ManualParameter('p_np_int32', initial_value=numpy.int32(5))
p2 = ManualParameter('p_np_float16', initial_value=numpy.float16(5.0))
p3 = ManualParameter('p_np_array',
initial_value=numpy.meshgrid((1, 2), (3, 4)))
p4 = ManualParameter('p_np_bool', initial_value=numpy.bool_(False))
station = Station(p1, p2, p3, p4)
measurement = Measurement(experiment, station)
# we need at least 1 parameter to be able to run the measurement
measurement.register_custom_parameter('dummy')
with measurement.run() as data_saver:
# we do this in order to create a snapshot of the station and add it
# to the database
pass
snapshot = data_saver.dataset.snapshot
assert 5 == snapshot['station']['parameters']['p_np_int32']['value']
assert 5 == snapshot['station']['parameters']['p_np_int32']['raw_value']
assert 5.0 == snapshot['station']['parameters']['p_np_float16']['value']
assert 5.0 == snapshot['station']['parameters']['p_np_float16'][
'raw_value']
lst = [[[1, 2], [1, 2]], [[3, 3], [4, 4]]]
assert lst == snapshot['station']['parameters']['p_np_array']['value']
assert lst == snapshot['station']['parameters']['p_np_array']['raw_value']
assert False is snapshot['station']['parameters']['p_np_bool']['value']
assert False is snapshot['station']['parameters']['p_np_bool']['raw_value']
def test_add_component_with_no_name():
"""
Test that station comes up with a name for components without 'name'
attribute
"""
bob = {'name', 'bob'}
station = Station()
station.add_component(bob)
assert ['component0'] == list(station.components.keys())
assert bob == station.components['component0']
jay = {'name', 'jay'}
station.add_component(jay)
assert ['component0', 'component1'] == list(station.components.keys())
assert jay == station.components['component1']
def test_remove_component():
bob = DummyInstrument('bob', gates=['one'])
station = Station()
station.add_component(bob, 'bob')
assert ['bob'] == list(station.components.keys())
assert bob == station.components['bob']
bob2 = station.remove_component('bob')
with pytest.raises(KeyError, match='bob'):
_ = station.components['bob']
assert bob == bob2
with pytest.raises(KeyError, match='Component bobby is not part of the '
'station'):
_ = station.remove_component('bobby')
def __init__(self, filename: Optional[str] = None,
station: Optional[Station] = None) -> None:
self.monitor_parameters = {}
if station is None:
station = Station.default or Station()
self.station = station
self.filename = filename
self.load_file(self.filename)
for instrument_name in self._instrument_config.keys():
# TODO: check if name is valid (does not start with digit, contain
# dot, other signs etc.)
method_name = f'load_{instrument_name}'
if method_name.isidentifier():
setattr(self, method_name,
partial(self.load_instrument,
identifier=instrument_name))
else:
log.warning(f'Invalid identifier: ' +
f'for the instrument {instrument_name} no ' +
f'lazy loading method {method_name} could be ' +
'created in the StationConfigurator')
def test_station_snapshot_during_measurement(experiment, dac, dmm,
pass_station):
station = Station()
station.add_component(dac)
station.add_component(dmm, 'renamed_dmm')
snapshot_of_station = station.snapshot()
if pass_station:
measurement = Measurement(experiment, station)
else:
# in this branch of the `if` we expect that `Measurement` object
# will be initialized with `Station.default` which is equal to the
# station object that is instantiated above
measurement = Measurement(experiment)
measurement.register_parameter(dac.ch1)
measurement.register_parameter(dmm.v1, setpoints=[dac.ch1])
with measurement.run() as data_saver:
data_saver.add_result((dac.ch1, 7), (dmm.v1, 5))
# 1. Test `get_metadata('snapshot')` method
json_snapshot_from_dataset = data_saver.dataset.get_metadata('snapshot')
snapshot_from_dataset = json.loads(json_snapshot_from_dataset)
expected_snapshot = {'station': snapshot_of_station}
assert expected_snapshot == snapshot_from_dataset
# 2. Test `snapshot_raw` property
assert json_snapshot_from_dataset == data_saver.dataset.snapshot_raw
# 3. Test `snapshot` property
assert expected_snapshot == data_saver.dataset.snapshot
def test_config_validation_comprehensive_config():
Station(config_file=os.path.join(
get_qcodes_path(), 'dist', 'tests', 'station', 'example.station.yaml')
)
def test_monitor_not_loaded_if_specified(example_station_config):
st = Station(config_file=example_station_config, use_monitor=False)
st.load_instrument('mock_dac')
assert Monitor.running is None
def test_monitor_not_loaded_by_default(example_station_config):
st = Station(config_file=example_station_config)
st.load_instrument('mock_dac')
assert Monitor.running is None
