qcodes.utils.helpers
- class qcodes.utils.helpers.DelegateAttributes[source]
Bases:
object
Mixin class to create attributes of this object by delegating them to one or more dictionaries and/or objects.
Also fixes
__dir__
so the delegated attributes will show up indir()
andautocomplete
.- Attribute resolution order:
Real attributes of this object.
Keys of each dictionary in
delegate_attr_dicts
(in order).Attributes of each object in
delegate_attr_objects
(in order).
- delegate_attr_dicts: List[str] = []
A list of names (strings) of dictionaries which are (or will be) attributes of
self
, whose keys should be treated as attributes ofself
.
- class qcodes.utils.helpers.NumpyJSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)[source]
Bases:
json.encoder.JSONEncoder
This JSON encoder adds support for serializing types that the built-in
json
module does not support out-of-the-box. See the docstring of thedefault
method for the description of all conversions.Constructor for JSONEncoder, with sensible defaults.
If skipkeys is false, then it is a TypeError to attempt encoding of keys that are not str, int, float or None. If skipkeys is True, such items are simply skipped.
If ensure_ascii is true, the output is guaranteed to be str objects with all incoming non-ASCII characters escaped. If ensure_ascii is false, the output can contain non-ASCII characters.
If check_circular is true, then lists, dicts, and custom encoded objects will be checked for circular references during encoding to prevent an infinite recursion (which would cause an RecursionError). Otherwise, no such check takes place.
If allow_nan is true, then NaN, Infinity, and -Infinity will be encoded as such. This behavior is not JSON specification compliant, but is consistent with most JavaScript based encoders and decoders. Otherwise, it will be a ValueError to encode such floats.
If sort_keys is true, then the output of dictionaries will be sorted by key; this is useful for regression tests to ensure that JSON serializations can be compared on a day-to-day basis.
If indent is a non-negative integer, then JSON array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. None is the most compact representation.
If specified, separators should be an (item_separator, key_separator) tuple. The default is (’, ‘, ‘: ‘) if indent is
None
and (‘,’, ‘: ‘) otherwise. To get the most compact JSON representation, you should specify (‘,’, ‘:’) to eliminate whitespace.If specified, default is a function that gets called for objects that can’t otherwise be serialized. It should return a JSON encodable version of the object or raise a
TypeError
.- default(obj: Any) Any [source]
List of conversions that this encoder performs:
numpy.generic
(all integer, floating, and other types) gets converted to its python equivalent using itsitem
method (seenumpy
docs for more information, https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html).numpy.ndarray
gets converted to python list using itstolist
method.Complex number (a number that conforms to
numbers.Complex
ABC) gets converted to a dictionary with fieldsre
andim
containing floating numbers for the real and imaginary parts respectively, and a field__dtype__
containing valuecomplex
.Numbers with uncertainties (numbers that conforms to
uncertainties.UFloat
) get converted to a dictionary with fieldsnominal_value
andstd_dev
containing floating numbers for the nominal and uncertainty parts respectively, and a field__dtype__
containing valueUFloat
.Object with a
_JSONEncoder
method get converted the return value of that method.Objects which support the pickle protocol get converted using the data provided by that protocol.
Other objects which cannot be serialized get converted to their string representation (using the
str
function).
- encode(o)
Return a JSON string representation of a Python data structure.
>>> from json.encoder import JSONEncoder >>> JSONEncoder().encode({"foo": ["bar", "baz"]}) '{"foo": ["bar", "baz"]}'
- item_separator = ', '
- iterencode(o, _one_shot=False)
Encode the given object and yield each string representation as available.
For example:
for chunk in JSONEncoder().iterencode(bigobject): mysocket.write(chunk)
- key_separator = ': '
- qcodes.utils.helpers.abstractmethod(funcobj: Callable[[...], Any]) Callable[[...], Any] [source]
A decorator indicating abstract methods.
This is heavily inspired by the decorator of the same name in the ABC standard library. But we make our own version because we actually want to allow the class with the abstract method to be instantiated and we will use this property to detect if the method is abstract and should be overwritten.
- qcodes.utils.helpers.add_to_spyder_UMR_excludelist(modulename: str) None [source]
Spyder tries to reload any user module. This does not work well for qcodes because it overwrites Class variables. QCoDeS uses these to store global attributes such as default station, monitor and list of instruments. This “feature” can be disabled by the gui. Unfortunately this cannot be disabled in a natural way programmatically so in this hack we replace the global
__umr__
instance with a new one containing the module we want to exclude. This will do nothing if Spyder is not found. TODO is there a better way to detect if we are in spyder?
- qcodes.utils.helpers.attribute_set_to(object_: object, attribute_name: str, new_value: Any) Iterator[None] [source]
This context manager allows to change a given attribute of a given object to a new value, and the original value is reverted upon exit of the context manager.
- Parameters
object – The object which attribute value is to be changed.
attribute_name – The name of the attribute that is to be changed.
new_value – The new value to which the attribute of the object is to be changed.
- qcodes.utils.helpers.checked_getattr(instance: Any, attribute: str, expected_type: Union[type, Tuple[type, ...]]) Any [source]
Like
getattr
but raises type error if not of expected type.
- qcodes.utils.helpers.compare_dictionaries(dict_1: Dict[Hashable, Any], dict_2: Dict[Hashable, Any], dict_1_name: Optional[str] = 'd1', dict_2_name: Optional[str] = 'd2', path: str = '') Tuple[bool, str] [source]
Compare two dictionaries recursively to find non matching elements.
- Parameters
dict_1 – First dictionary to compare.
dict_2 – Second dictionary to compare.
dict_1_name – Optional name of the first dictionary used in the differences string.
dict_2_name – Optional name of the second dictionary used in the differences string.
- Returns
- Are the dicts equal and the difference rendered as
a string.
- Return type
Tuple
- qcodes.utils.helpers.create_on_off_val_mapping(on_val: Any = True, off_val: Any = False) Dict[Union[str, bool], Any] [source]
Returns a value mapping which maps inputs which reasonably mean “on”/”off” to the specified
on_val
/off_val
which are to be sent to the instrument. This value mapping is such that, when inverted,on_val
/off_val
are mapped to booleanTrue
/False
.
- qcodes.utils.helpers.deep_update(dest: MutableMapping[qcodes.utils.helpers.K, Any], update: Mapping[qcodes.utils.helpers.L, Any]) MutableMapping[Union[qcodes.utils.helpers.K, qcodes.utils.helpers.L], Any] [source]
Recursively update one JSON structure with another.
Only dives into nested dicts; lists get replaced completely. If the original value is a dictionary and the new value is not, or vice versa, we also replace the value completely.
- qcodes.utils.helpers.foreground_qt_window(window: QMainWindow) None [source]
Try as hard as possible to bring a qt window to the front. This will use pywin32 if installed and running on windows as this seems to be the only reliable way to foreground a window. The build-in qt functions often doesn’t work. Note that to use this with pyqtgraphs remote process you should use the ref in that module as in the example below.
- Parameters
window – Handle to qt window to foreground.
Examples
>>> Qtplot.qt_helpers.foreground_qt_window(plot.win)
- qcodes.utils.helpers.full_class(obj: object) str [source]
The full importable path to an object’s class.
- qcodes.utils.helpers.get_qcodes_path(*subfolder: str) str [source]
Return full file path of the QCoDeS module. Additional arguments will be appended as subfolder.
- qcodes.utils.helpers.get_qcodes_user_path(*file_parts: str) str [source]
Get
~/.qcodes
path or if defined the path defined in theQCODES_USER_PATH
environment variable.- Returns
path to the user qcodes directory
- qcodes.utils.helpers.is_function(f: object, arg_count: int, coroutine: bool = False) bool [source]
Check and require a function that can accept the specified number of positional arguments, which either is or is not a coroutine type casting “functions” are allowed, but only in the 1-argument form.
- Parameters
f – Function to check.
arg_count – Number of argument f should accept.
coroutine – Is a coroutine.
- Returns
is function and accepts the specified number of arguments.
- Return type
- qcodes.utils.helpers.is_sequence(obj: Any) bool [source]
Test if an object is a sequence.
We do not consider strings or unordered collections like sets to be sequences, but we do accept iterators (such as generators).
- qcodes.utils.helpers.is_sequence_of(obj: Any, types: Optional[Union[Type[object], Tuple[Type[object], ...]]] = None, depth: Optional[int] = None, shape: Optional[Sequence[int]] = None) bool [source]
Test if object is a sequence of entirely certain class(es).
- Parameters
obj – The object to test.
types – Allowed type(s). If omitted, we just test the depth/shape.
depth – Level of nesting, ie if
depth=2
we expect a sequence of sequences. Default 1 unlessshape
is supplied.shape – The shape of the sequence, ie its length in each dimension. If
depth
is omitted, butshape
included, we setdepth = len(shape)
.
- Returns
True
if every item inobj
matchestypes
.- Return type
- qcodes.utils.helpers.make_sweep(start: float, stop: float, step: Optional[float] = None, num: Optional[int] = None) List[float] [source]
Generate numbers over a specified interval. Requires
start
andstop
and (step
ornum
). The sign ofstep
is not relevant.- Parameters
start – The starting value of the sequence.
stop – The end value of the sequence.
step – Spacing between values.
num – Number of values to generate.
- Returns
numbers over a specified interval as a
numpy.linspace
.- Return type
Examples
>>> make_sweep(0, 10, num=5) [0.0, 2.5, 5.0, 7.5, 10.0] >>> make_sweep(5, 10, step=1) [5.0, 6.0, 7.0, 8.0, 9.0, 10.0] >>> make_sweep(15, 10.5, step=1.5) >[15.0, 13.5, 12.0, 10.5]
- qcodes.utils.helpers.named_repr(obj: Any) str [source]
Enhance the standard repr() with the object’s name attribute.
- qcodes.utils.helpers.partial_with_docstring(func: Callable[[...], Any], docstring: str, **kwargs: Any) Callable[[...], Any] [source]
We want to have a partial function which will allow us to access the docstring through the python built-in help function. This is particularly important for client-facing driver methods, whose arguments might not be obvious.
Consider the follow example why this is needed:
>>> from functools import partial >>> def f(): >>> ... pass >>> g = partial(f) >>> g.__doc__ = "bla" >>> help(g) # this will print the docstring of partial and not the docstring set above
- Parameters
func – A function that its docstring will be accessed.
docstring – The docstring of the corresponding function.
- qcodes.utils.helpers.permissive_range(start: float, stop: float, step: SupportsAbs[float]) List[float] [source]
Returns a range (as a list of values) with floating point steps. Always starts at start and moves toward stop, regardless of the sign of step.
- Parameters
start – The starting value of the range.
stop – The end value of the range.
step – Spacing between the values.
- qcodes.utils.helpers.strip_attrs(obj: object, whitelist: Sequence[str] = ()) None [source]
Irreversibly remove all direct instance attributes of object, to help with disposal, breaking circular references.
- Parameters
obj – Object to be stripped.
whitelist – List of names that are not stripped from the object.
- qcodes.utils.helpers.tprint(string: str, dt: int = 1, tag: str = 'default') None [source]
Print progress of a loop every
dt
seconds.