semi_cr.core.lab.pins package

Submodules

semi_cr.core.lab.pins.PinChannelList module

class semi_cr.core.lab.pins.PinChannelList.BasePinChannelList(parent, name: 'str') → 'None'

Bases: ChannelList

__add__(other: ChannelTuple) → Self

Return a new ChannelTuple containing the channels from both ChannelTuple self and r.

Both ChannelTuple must hold the same type and have the same parent.

Parameters:

other – Right argument to add.

__getattr__(name: str) → Any

Look up an attribute by name. If this is the name of a parameter or a function on the channel type contained in this container return a multi-channel function or parameter that can be used to get or set all items in a channel list simultaneously. If this is the name of a channel, return that channel. This interface is not type safe as it will return any matching attribute. To get a channel by name use get_channels_by_name instead. To get a parameter use multi_parameter. To get a a callable or a qcodes function use multi_function

Parameters:

name – The name of the parameter, function or channel that we want to operate on.

__getitem__(i: int | slice | tuple[int, ...]) → InstrumentModuleType | Self

Return either a single channel, or a new ChannelTuple containing only the specified channels

Parameters:

i – Either a single channel index or a slice of channels to get

append(obj: InstrumentModuleType) → None

Append a Channel to this list. Requires that the ChannelList is not locked and that the channel is of the same type as the ones in the list.

Parameters:

obj – New channel to add to the list.

clear() → None

Clear all items from the ChannelList.

count(obj: InstrumentModuleType) → int

Returns number of instances of the given object in the list

Parameters:

obj – The object to find in the ChannelTuple.

extend(objects: Iterable[InstrumentModuleType]) → None

Insert an iterable of objects into the list of channels.

Parameters:

objects – A list of objects to add into the ChannelList.

property full_name: str

Name including name of any parent that this object is bound to separated by ‘_’.

get_channel_by_name(name: str) → InstrumentModuleType

Get a channel by name.

Parameters:

name – channel name

get_channels_by_name(*names: str) → Self

Get a a ChannelTuple that only contains the selected names.

Parameters:

*names – channel names

get_validator() → ChannelTupleValidator

Returns a validator that checks that the returned object is a channel in this ChannelList.

Raises:

AttributeError – If the ChannelList is not locked.

index(obj: InstrumentModuleType, start: int = 0, stop: int = 9223372036854775807) → int

Return the index of the given object

Parameters:

• obj – The object to find in the channel list.

• start – Index to start searching from.

• stop – Index to stop searching at.

insert(index: int, obj: InstrumentModuleType) → None

Insert an object into the ChannelList at a specific index.

Parameters:

• index – Index to insert object.

• obj – Object of type chan_type to insert.

invalidate_cache() → None

Invalidate the cache of all parameters on the ChannelTuple.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

lock() → None

Lock the channel list. Once this is done, the ChannelList is locked and any future changes to the list are prevented. Note this is not recommended and may be deprecated in the future. Use to_channel_tuple to convert this into a tuple instead.

multi_function(name: str) → Callable[[...], None]

Look up a callable or QCoDeS function by name. If this is the name of a callable or function on the channel type contained in this container return a callable that calls this callable on all channels in the Sequence

Parameters:

name – The name of the callable/function that we want to operate on.

Returns:

Callable that calls the functions/callables on all channels in the Sequence.

Raises:

AttributeError – If no callable with the given name exists.

multi_parameter(name: str) → MultiChannelInstrumentParameter[InstrumentModuleType]

Look up a parameter by name. If this is the name of a parameter on the channel type contained in this container return a multi-channel parameter that controls this parameter on all channels in the Sequence.

Parameters:

name – The name of the parameter that we want to operate on.

Returns:

The multi-channel parameter

that can be used to get or set all items in a channel list simultaneously.

Return type:

MultiChannelInstrumentParameter

Raises:

AttributeError – If no parameter with the given name exists.

property name_parts: list[str]

List of the parts that make up the full name of this function

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

remove(obj: InstrumentModuleType) → None

Removes obj from ChannelList if not locked.

Parameters:

obj – Channel to remove from the list.

reverse()

S.reverse() – reverse IN PLACE

property short_name: str

Name excluding name of any parent that this object is bound to.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None only update if the state is known to be invalid. If False, just use the latest values in memory and never update.

• 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:

base snapshot

Return type:

dict

to_channel_tuple() → ChannelTuple[InstrumentModuleType]

Returns a ChannelTuple build from this ChannelList containing the same channels but without the ability to be modified.

metadata: dict[str, Any]

class semi_cr.core.lab.pins.PinChannelList.PinChannelList(parent, name: str)

Bases: BasePinChannelList

get_pin_by_name_and_type(pin_name: str, channel_type: type[C]) → C

get_source(source_name: str) → Source

get_gate(gate_name: str) → Gate

get_drain(drain_name: str) → Drain

get_ohmic(ohmic_name: str) → Ohmic

property gates: list[Gate]

property sources: list[Source]

property drains: list[Drain]

property ohmics: list[Ohmic]

__add__(other: ChannelTuple) → Self

Return a new ChannelTuple containing the channels from both ChannelTuple self and r.

Both ChannelTuple must hold the same type and have the same parent.

Parameters:

other – Right argument to add.

__getattr__(name: str) → Any

Look up an attribute by name. If this is the name of a parameter or a function on the channel type contained in this container return a multi-channel function or parameter that can be used to get or set all items in a channel list simultaneously. If this is the name of a channel, return that channel. This interface is not type safe as it will return any matching attribute. To get a channel by name use get_channels_by_name instead. To get a parameter use multi_parameter. To get a a callable or a qcodes function use multi_function

Parameters:

name – The name of the parameter, function or channel that we want to operate on.

__getitem__(i: int | slice | tuple[int, ...]) → InstrumentModuleType | Self

Return either a single channel, or a new ChannelTuple containing only the specified channels

Parameters:

i – Either a single channel index or a slice of channels to get

append(obj: InstrumentModuleType) → None

Append a Channel to this list. Requires that the ChannelList is not locked and that the channel is of the same type as the ones in the list.

Parameters:

obj – New channel to add to the list.

clear() → None

Clear all items from the ChannelList.

count(obj: InstrumentModuleType) → int

Returns number of instances of the given object in the list

Parameters:

obj – The object to find in the ChannelTuple.

extend(objects: Iterable[InstrumentModuleType]) → None

Insert an iterable of objects into the list of channels.

Parameters:

objects – A list of objects to add into the ChannelList.

property full_name: str

Name including name of any parent that this object is bound to separated by ‘_’.

get_channel_by_name(name: str) → InstrumentModuleType

Get a channel by name.

Parameters:

name – channel name

get_channels_by_name(*names: str) → Self

Get a a ChannelTuple that only contains the selected names.

Parameters:

*names – channel names

get_validator() → ChannelTupleValidator

Returns a validator that checks that the returned object is a channel in this ChannelList.

Raises:

AttributeError – If the ChannelList is not locked.

index(obj: InstrumentModuleType, start: int = 0, stop: int = 9223372036854775807) → int

Return the index of the given object

Parameters:

• obj – The object to find in the channel list.

• start – Index to start searching from.

• stop – Index to stop searching at.

insert(index: int, obj: InstrumentModuleType) → None

Insert an object into the ChannelList at a specific index.

Parameters:

• index – Index to insert object.

• obj – Object of type chan_type to insert.

invalidate_cache() → None

Invalidate the cache of all parameters on the ChannelTuple.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

lock() → None

Lock the channel list. Once this is done, the ChannelList is locked and any future changes to the list are prevented. Note this is not recommended and may be deprecated in the future. Use to_channel_tuple to convert this into a tuple instead.

multi_function(name: str) → Callable[[...], None]

Look up a callable or QCoDeS function by name. If this is the name of a callable or function on the channel type contained in this container return a callable that calls this callable on all channels in the Sequence

Parameters:

name – The name of the callable/function that we want to operate on.

Returns:

Callable that calls the functions/callables on all channels in the Sequence.

Raises:

AttributeError – If no callable with the given name exists.

multi_parameter(name: str) → MultiChannelInstrumentParameter[InstrumentModuleType]

Look up a parameter by name. If this is the name of a parameter on the channel type contained in this container return a multi-channel parameter that controls this parameter on all channels in the Sequence.

Parameters:

name – The name of the parameter that we want to operate on.

Returns:

The multi-channel parameter

that can be used to get or set all items in a channel list simultaneously.

Return type:

MultiChannelInstrumentParameter

Raises:

AttributeError – If no parameter with the given name exists.

property name_parts: list[str]

List of the parts that make up the full name of this function

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

remove(obj: InstrumentModuleType) → None

Removes obj from ChannelList if not locked.

Parameters:

obj – Channel to remove from the list.

reverse()

S.reverse() – reverse IN PLACE

property short_name: str

Name excluding name of any parent that this object is bound to.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None only update if the state is known to be invalid. If False, just use the latest values in memory and never update.

• 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:

base snapshot

Return type:

dict

to_channel_tuple() → ChannelTuple[InstrumentModuleType]

Returns a ChannelTuple build from this ChannelList containing the same channels but without the ability to be modified.

metadata: dict[str, Any]

class semi_cr.core.lab.pins.PinChannelList.RFPinChannelList(parent, name: str)

Bases: BasePinChannelList

get_pin_by_name_and_type(pin_name: str, channel_type: type[D]) → D

get_rf_input(source_name: str) → RFInput

get_rf_output(gate_name: str) → Gate

property rf_inputs: list[RFInput]

property rf_outputs: list[RFOutput]

__add__(other: ChannelTuple) → Self

Return a new ChannelTuple containing the channels from both ChannelTuple self and r.

Both ChannelTuple must hold the same type and have the same parent.

Parameters:

other – Right argument to add.

__getattr__(name: str) → Any

Look up an attribute by name. If this is the name of a parameter or a function on the channel type contained in this container return a multi-channel function or parameter that can be used to get or set all items in a channel list simultaneously. If this is the name of a channel, return that channel. This interface is not type safe as it will return any matching attribute. To get a channel by name use get_channels_by_name instead. To get a parameter use multi_parameter. To get a a callable or a qcodes function use multi_function

Parameters:

name – The name of the parameter, function or channel that we want to operate on.

__getitem__(i: int | slice | tuple[int, ...]) → InstrumentModuleType | Self

Return either a single channel, or a new ChannelTuple containing only the specified channels

Parameters:

i – Either a single channel index or a slice of channels to get

append(obj: InstrumentModuleType) → None

Append a Channel to this list. Requires that the ChannelList is not locked and that the channel is of the same type as the ones in the list.

Parameters:

obj – New channel to add to the list.

clear() → None

Clear all items from the ChannelList.

count(obj: InstrumentModuleType) → int

Returns number of instances of the given object in the list

Parameters:

obj – The object to find in the ChannelTuple.

extend(objects: Iterable[InstrumentModuleType]) → None

Insert an iterable of objects into the list of channels.

Parameters:

objects – A list of objects to add into the ChannelList.

property full_name: str

Name including name of any parent that this object is bound to separated by ‘_’.

get_channel_by_name(name: str) → InstrumentModuleType

Get a channel by name.

Parameters:

name – channel name

get_channels_by_name(*names: str) → Self

Get a a ChannelTuple that only contains the selected names.

Parameters:

*names – channel names

get_validator() → ChannelTupleValidator

Returns a validator that checks that the returned object is a channel in this ChannelList.

Raises:

AttributeError – If the ChannelList is not locked.

index(obj: InstrumentModuleType, start: int = 0, stop: int = 9223372036854775807) → int

Return the index of the given object

Parameters:

• obj – The object to find in the channel list.

• start – Index to start searching from.

• stop – Index to stop searching at.

insert(index: int, obj: InstrumentModuleType) → None

Insert an object into the ChannelList at a specific index.

Parameters:

• index – Index to insert object.

• obj – Object of type chan_type to insert.

invalidate_cache() → None

Invalidate the cache of all parameters on the ChannelTuple.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

lock() → None

Lock the channel list. Once this is done, the ChannelList is locked and any future changes to the list are prevented. Note this is not recommended and may be deprecated in the future. Use to_channel_tuple to convert this into a tuple instead.

multi_function(name: str) → Callable[[...], None]

Look up a callable or QCoDeS function by name. If this is the name of a callable or function on the channel type contained in this container return a callable that calls this callable on all channels in the Sequence

Parameters:

name – The name of the callable/function that we want to operate on.

Returns:

Callable that calls the functions/callables on all channels in the Sequence.

Raises:

AttributeError – If no callable with the given name exists.

multi_parameter(name: str) → MultiChannelInstrumentParameter[InstrumentModuleType]

Look up a parameter by name. If this is the name of a parameter on the channel type contained in this container return a multi-channel parameter that controls this parameter on all channels in the Sequence.

Parameters:

name – The name of the parameter that we want to operate on.

Returns:

The multi-channel parameter

that can be used to get or set all items in a channel list simultaneously.

Return type:

MultiChannelInstrumentParameter

Raises:

AttributeError – If no parameter with the given name exists.

property name_parts: list[str]

List of the parts that make up the full name of this function

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

remove(obj: InstrumentModuleType) → None

Removes obj from ChannelList if not locked.

Parameters:

obj – Channel to remove from the list.

reverse()

S.reverse() – reverse IN PLACE

property short_name: str

Name excluding name of any parent that this object is bound to.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = True, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• update – If True, update the state by querying the instrument. If None only update if the state is known to be invalid. If False, just use the latest values in memory and never update.

• 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:

base snapshot

Return type:

dict

to_channel_tuple() → ChannelTuple[InstrumentModuleType]

Returns a ChannelTuple build from this ChannelList containing the same channels but without the ability to be modified.

metadata: dict[str, Any]

semi_cr.core.lab.pins.base module

class semi_cr.core.lab.pins.base.PinInfo

Bases: TypedDict

type: str

pads: Sequence[str]

clear() → None.  Remove all items from D.

copy() → a shallow copy of D

classmethod fromkeys(iterable, value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from dict/iterable E and F.

If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values

class semi_cr.core.lab.pins.base.BasePinChannel(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: InstrumentChannel

property instruments: list[InstrumentBase]

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

semi_cr.core.lab.pins.pins module

class semi_cr.core.lab.pins.pins.DCPinChannel(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: BasePinChannel

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Gate(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: DCPinChannel

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Ohmic(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: DCPinChannel

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Source(parent, name: str, instruments=None, **kwargs)

Bases: Ohmic

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Drain(parent, name: str, instruments=None, **kwargs)

Bases: Ohmic

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Plunger(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: Gate

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Screening(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: Gate

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Cutter(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: Gate

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.Barrier(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: Gate

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.RFPinChannel(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: BasePinChannel

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.RFInput(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: RFPinChannel

property rf_drive

update_frequency(frequency)

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

class semi_cr.core.lab.pins.pins.RFOutput(parent, name: str, instruments: Sequence[InstrumentBase] | None = None, **kwargs)

Bases: RFPinChannel

__getitem__(key: str) → Callable[[...], Any] | Parameter

Delegate instrument[‘name’] to parameter or function ‘name’.

Note

This is deprecated. Use attributes directly or if dynamic attribute required look up via .parameters or .functions dictionaries

__getstate__() → None

Prevent pickling instruments, and give a nice error message.

add_function(name: str, **kwargs: Any) → None

Bind one Function to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real function of the instrument.

This functionality is meant for simple cases, principally things that map to simple commands like *RST (reset) or those with just a few arguments. It requires a fixed argument count, and positional args only.

Note

We do not recommend the usage of Function for any new driver. Function does not add any significant features over a method defined on the class.

Parameters:

• name – How the Function will be stored within instrument.Functions and also how you address it using the shortcut methods: instrument.call(func_name, *args) etc.

• **kwargs – constructor kwargs for Function

Raises:

KeyError – If this instrument already has a function with this name.

add_parameter(name: str, parameter_class: type[TParameter] | None = None, **kwargs: Any) → TParameter

Bind one Parameter to this instrument.

Instrument subclasses can call this repeatedly in their __init__ for every real parameter of the instrument.

In this sense, parameters are the state variables of the instrument, anything the user can set and/or get.

Parameters:

• name – How the parameter will be stored within parameters and also how you address it using the shortcut methods: instrument.set(param_name, value) etc.

• parameter_class – You can construct the parameter out of any class. Default parameters.Parameter.

• **kwargs – Constructor arguments for parameter_class.

Raises:

• KeyError – If this instrument already has a parameter with this name and the parameter being replaced is not an abstract parameter.

• ValueError – If there is an existing abstract parameter and the unit of the new parameter is inconsistent with the existing one.

Returns:

The created Parameter.

add_submodule(name: str, submodule: TSubmodule) → TSubmodule

Bind one submodule to this instrument.

Instrument subclasses can call this repeatedly in their __init__ method for every submodule of the instrument.

Submodules can effectively be considered as instruments within the main instrument, and should at minimum be snapshottable. For example, they can be used to either store logical groupings of parameters, which may or may not be repeated, or channel lists. They should either be an instance of an InstrumentModule or a ChannelTuple.

Parameters:

• name – How the submodule will be stored within instrument.submodules and also how it can be addressed.

• submodule – The submodule to be stored.

Raises:

• KeyError – If this instrument already contains a submodule with this name.

• TypeError – If the submodule that we are trying to add is not an instance of an Metadatable object.

Returns:

The submodule.

property ancestors: tuple[InstrumentBase, ...]

Ancestors in the form of a list of InstrumentBase

The list starts with the current module then the parent and the parents parent until the root instrument is reached.

ask(cmd: str) → str

ask_raw(cmd: str) → str

call(func_name: str, *args: Any) → Any

Shortcut for calling a function from its name.

Parameters:

• func_name – The name of a function of this instrument.

• *args – any arguments to the function.

Returns:

The return value of the function.

Note

This is deprecated. Call the function directly.

delegate_attr_dicts = ['parameters', 'functions', 'submodules']

A list of names (strings) of dictionaries which are (or will be) attributes of self, whose keys should be treated as attributes of self.

delegate_attr_objects = []

A list of names (strings) of objects which are (or will be) attributes of self, whose attributes should be passed through to self.

property full_name: str

Full name of the instrument.

For an InstrumentModule this includes all parents separated by _

get(param_name: str) → Any

Shortcut for getting a parameter from its name.

Parameters:

param_name – The name of a parameter of this instrument.

Returns:

The current value of the parameter.

Note

This is deprecated. Call get directly on the parameter.

get_component(full_name: str) → MetadatableWithName

Recursively get a component of the instrument by full_name.

Parameters:

full_name – The name of the component to get.

Returns:

The component with the given name.

Raises:

KeyError – If the component does not exist.

property instruments: list[InstrumentBase]

invalidate_cache() → None

Invalidate the cache of all parameters on the instrument. Calling this method will recursively mark the cache of all parameters on the instrument and any parameter on instrument modules as invalid.

This is useful if you have performed manual operations (e.g. using the frontpanel) which changes the state of the instrument outside QCoDeS.

This in turn means that the next snapshot of the instrument will trigger a (potentially slow) reread of all parameters of the instrument if you pass update=None to snapshot.

property label: str

Nicely formatted label of the instrument.

load_metadata(metadata: Mapping[str, Any]) → None

Load metadata into this classes metadata dictionary.

Parameters:

metadata – Metadata to load.

property name: str

Full name of the instrument

This is equivalent to full_name() for backwards compatibility.

property name_parts: list[str]

A list of all the parts of the instrument name from root_instrument() to the current InstrumentModule.

omit_delegate_attrs = []

A list of attribute names (strings) to not delegate to any other dictionary or object.

property parent: _TIB_co

The parent instrument. By default, this is None. Any SubInstrument should subclass this to return the parent instrument.

print_readable_snapshot(update: bool = False, max_chars: int = 80) → None

Prints a readable version of the snapshot. The readable snapshot includes the name, value and unit of each parameter. A convenience function to quickly get an overview of the status of an instrument.

Parameters:

• update – If True, update the state by querying the instrument. If False, just use the latest values in memory. This argument gets passed to the snapshot function.

• max_chars – the maximum number of characters per line. The readable snapshot will be cropped if this value is exceeded. Defaults to 80 to be consistent with default terminal width.

remove_parameter(name: str) → None

Remove a Parameter from this instrument.

Unlike modifying the parameters dict directly, this method will make sure that the parameter is properly unbound from the instrument if the parameter is added as a real attribute to the instrument. If a property of the same name exists it will not be modified. If name is an attribute but not a parameter, it will not be modified.

Parameters:

name – The name of the parameter to remove.

Raises:

KeyError – If the parameter does not exist on the instrument.

property root_instrument: InstrumentBase

The topmost parent of this module.

For the root_instrument this is self.

set(param_name: str, value: Any) → None

Shortcut for setting a parameter from its name and new value.

Parameters:

• param_name – The name of a parameter of this instrument.

• value – The new value to set.

Note

This is deprecated. Call set directly on the parameter.

property short_name: str

Short name of the instrument.

For an InstrumentModule this does not include any parent names.

snapshot(update: bool | None = False) → dict[str, Any]

Decorate a snapshot dictionary with metadata. DO NOT override this method if you want metadata in the snapshot instead, override snapshot_base().

Parameters:

update – Passed to snapshot_base.

Returns:

Base snapshot.

snapshot_base(update: bool | None = False, params_to_skip_update: Sequence[str] | None = None) → dict[Any, Any]

State of the instrument as a JSON-compatible dict (everything that the custom JSON encoder class NumpyJSONEncoder supports).

Parameters:

• 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:

base snapshot

Return type:

dict

validate_status(verbose: bool = False) → None

Validate the values of all gettable parameters

The validation is done for all parameters that have both a get and set method.

Parameters:

verbose – If True, then information about the parameters that are being check is printed.

write(cmd: str) → None

write_raw(cmd: str) → None

parameters

All the parameters supported by this instrument. Usually populated via add_parameter().

functions

All the functions supported by this instrument. Usually populated via add_function().

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

Module contents