qcodespp 0.1.0__tar.gz

qcodespp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 djcarrad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qcodespp-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: qcodespp
+Version: 0.1.0
+Summary: Package providing additional functions for QCoDeS
+Maintainer-email: Damon Carrad <damonc@dtu.dk>
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+License-File: LICENSE
+Requires-Dist: qcodes
+Requires-Dist: numpy>=1.10
+Requires-Dist: pyqtgraph
+Requires-Dist: matplotlib
+Requires-Dist: PyQt5
+Requires-Dist: ipykernel
+Requires-Dist: jupyter
+Requires-Dist: pyvisa
+Requires-Dist: h5py>=2.6
+Requires-Dist: websockets>=3.2
+Requires-Dist: jsonschema
+Requires-Dist: pyzmq
+Requires-Dist: wrapt
+Requires-Dist: pyserial
+Requires-Dist: pandas
+Requires-Dist: tqdm
+Requires-Dist: scipy
+Requires-Dist: lmfit
+Project-URL: Homepage, https://github.com/qcodespp/qcodespp
+
+qcodes++
+===================================
+
+qcodes++ (aka qcodespp, qcpp, qc++) is a python package to run scientific experiments. qcodes++ is built on top of `QCoDeS <https://qcodes.github.io/Qcodes/>`__, both extending capabilities and preserving older features.
+
+QCoDeS is a Python-based data acquisition framework developed by the
+Copenhagen / Delft / Sydney / Microsoft quantum computing consortium.
+It contains a huge range of drivers for communicating with instruments,
+and a flexible - but complex - database-based method for collecting data
+and running measurement loops.
+
+The qcodes++ package provides a user-friendly
+frontend to the solid backend of QCoDeS. If you have always wanted to run 
+your measurements using python but found QCoDeS too daunting, qcodes++ is 
+the package for you. qcodes++ features
+
+* Text-based data (i.e. readable by e.g. notepad, excel, origin pro, etc)
+* A simple yet powerful method for taking data and running measurements and loops
+* True live plotting and an integrated offline plotting/analysis tool
+* Improvements to core qcodes functions (e.g. Station, Parameters) to streamline data acquisition, protect (meta)data integtrity and minimise user error
+* Improved drivers for certain instruments
+* and other user-friendliness improvements
+
+`qcodes++ is installed alongside/around QCoDeS <https://qcodespp.github.io/differences_from_qcodes.html>`__, meaning all features of both packages can be used 
+seamlessly within the same notebook/environment. e.g. you could still use the QCoDeS 
+dataset and measurement process for some experiments while relying on qcodes++ in other instances.
+In addition, all top level qcodes functions are available in qcodes++ with the same names.
+
+The name: In addition to being a really stupid pun on q(c++), it reflects the fact that really we just want 
+to add some nice features to the main package, and also it makes me happy because totally 
+coincidentally we have always named our plotting windows pp, e.g. pp = qc.live_plot().
+
+Documentation
+=============
+is available at https://qcodespp.github.io
+
+Installation
+============
+
+See https://qcodespp.github.io/installation.html
+
+QCoDeS and qcodes++ are compatible with Python 3.9+. They are primarily intended for use
+from Jupyter notebooks and Jupyter lab, but can also be used from Spyder, traditional terminal-based
+shells and in stand-alone scripts.
+
+License
+=======
+
+See `License <https://github.com/QCoDeS/Qcodes/tree/master/LICENSE.rst>`__.
+
+Contact and contributing
+==================================================
+
+This package is largely maintained by Damon Carrad. If you have a question, or want to contribute, please don't hesitate to contact me at damonc@dtu.dk. Note I'm mainly doing it in my spare time, but I will always try to help.

qcodespp-0.1.0/README.rst

@@ -0,0 +1,54 @@
+qcodes++
+===================================
+
+qcodes++ (aka qcodespp, qcpp, qc++) is a python package to run scientific experiments. qcodes++ is built on top of `QCoDeS <https://qcodes.github.io/Qcodes/>`__, both extending capabilities and preserving older features.
+
+QCoDeS is a Python-based data acquisition framework developed by the
+Copenhagen / Delft / Sydney / Microsoft quantum computing consortium.
+It contains a huge range of drivers for communicating with instruments,
+and a flexible - but complex - database-based method for collecting data
+and running measurement loops.
+
+The qcodes++ package provides a user-friendly
+frontend to the solid backend of QCoDeS. If you have always wanted to run 
+your measurements using python but found QCoDeS too daunting, qcodes++ is 
+the package for you. qcodes++ features
+
+* Text-based data (i.e. readable by e.g. notepad, excel, origin pro, etc)
+* A simple yet powerful method for taking data and running measurements and loops
+* True live plotting and an integrated offline plotting/analysis tool
+* Improvements to core qcodes functions (e.g. Station, Parameters) to streamline data acquisition, protect (meta)data integtrity and minimise user error
+* Improved drivers for certain instruments
+* and other user-friendliness improvements
+
+`qcodes++ is installed alongside/around QCoDeS <https://qcodespp.github.io/differences_from_qcodes.html>`__, meaning all features of both packages can be used 
+seamlessly within the same notebook/environment. e.g. you could still use the QCoDeS 
+dataset and measurement process for some experiments while relying on qcodes++ in other instances.
+In addition, all top level qcodes functions are available in qcodes++ with the same names.
+
+The name: In addition to being a really stupid pun on q(c++), it reflects the fact that really we just want 
+to add some nice features to the main package, and also it makes me happy because totally 
+coincidentally we have always named our plotting windows pp, e.g. pp = qc.live_plot().
+
+Documentation
+=============
+is available at https://qcodespp.github.io
+
+Installation
+============
+
+See https://qcodespp.github.io/installation.html
+
+QCoDeS and qcodes++ are compatible with Python 3.9+. They are primarily intended for use
+from Jupyter notebooks and Jupyter lab, but can also be used from Spyder, traditional terminal-based
+shells and in stand-alone scripts.
+
+License
+=======
+
+See `License <https://github.com/QCoDeS/Qcodes/tree/master/LICENSE.rst>`__.
+
+Contact and contributing
+==================================================
+
+This package is largely maintained by Damon Carrad. If you have a question, or want to contribute, please don't hesitate to contact me at damonc@dtu.dk. Note I'm mainly doing it in my spare time, but I will always try to help.

qcodespp-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+
+build-backend = 'flit_core.buildapi'
+
+[project]
+name = "qcodespp"
+version = '0.1.0'
+maintainers = [{name = "Damon Carrad", email = "damonc@dtu.dk"}]
+description = "Package providing additional functions for QCoDeS"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [ 
+    "qcodes",
+    'numpy>=1.10',
+    'pyqtgraph',
+    'matplotlib',
+    'PyQt5',
+    'ipykernel',
+    'jupyter',
+    'pyvisa',
+    'h5py>=2.6',
+    'websockets>=3.2',
+    'jsonschema',
+    'pyzmq',
+    'wrapt',
+    'pyserial',
+    'pandas',
+    'tqdm',
+    'scipy',
+    'lmfit'
+]
+
+[project.readme]
+file = "README.rst"
+content-type = "text/x-rst"
+
+[project.urls]
+Homepage = "https://github.com/qcodespp/qcodespp"

qcodespp-0.1.0/qcodespp/__init__.py

@@ -0,0 +1,77 @@
+from qcodes.configuration import Config
+config = Config() # type: Config
+
+# Import all modules included in the qcodes namespace, except Parameter and Station
+# as these need to go through qcodespp wrappers
+from qcodes.dataset import (
+    Measurement,
+    ParamSpec,
+    SQLiteSettings,
+    experiments,
+    get_guids_by_run_spec,
+    initialise_database,
+    initialise_or_create_database_at,
+    initialised_database_at,
+    load_by_counter,
+    load_by_guid,
+    load_by_id,
+    load_by_run_spec,
+    load_experiment,
+    load_experiment_by_name,
+    load_last_experiment,
+    load_or_create_experiment,
+    new_data_set,
+    new_experiment,
+)
+from qcodes.instrument import (
+    ChannelList,
+    ChannelTuple,
+    Instrument,
+    InstrumentChannel,
+    IPInstrument,
+    VisaInstrument,
+    find_or_create_instrument,
+)
+from qcodes.monitor import Monitor
+from qcodes.parameters import (
+    ArrayParameter,
+    CombinedParameter,
+    DelegateParameter,
+    Function,
+    ManualParameter,
+    MultiParameter,
+    #Parameter,
+    ParameterWithSetpoints,
+    ScaledParameter,
+    SweepFixedValues,
+    SweepValues,
+    combine,
+)
+
+from qcodes.utils import deprecate
+from qcodes.parameters import ElapsedTimeParameter
+
+# modules from qcodes that have been extended/modified
+from qcodespp.parameters import Parameter
+
+from qcodespp.station import Station
+
+# new modules not included in qcodes
+from qcodespp.version import __version__
+
+from qcodespp.loops import Loop, loop1d,loop2d,loop2dUD
+from qcodespp.measure import Measure
+from qcodespp.actions import Task, Wait, BreakIf
+
+from qcodespp.plotting.RemotePlot import Plot, live_plot
+from qcodespp.plotting.offline.main import offline_plotting
+
+from qcodespp.data.data_set import new_data, load_data, load_data_num, load_data_nums, set_data_format, set_data_folder
+
+from qcodespp.utils.visa_helpers import listVISAinstruments
+
+from qcodespp.parameters import MultiParameterWrapper, ArrayParameterWrapper
+
+# ensure to close all instruments when interpreter is closed
+import atexit
+atexit.register(Instrument.close_all)

qcodespp-0.1.0/qcodespp/actions.py

@@ -0,0 +1,237 @@
+"""Actions, mainly to be executed in measurement Loops."""
+import time
+
+from qcodes.utils.helpers import is_function
+from qcodes.utils.threading import thread_map
+
+
+_NO_SNAPSHOT = {'type': None, 'description': 'Action without snapshot'}
+
+
+# exception when threading is attempted used to simultaneously
+# query the same instrument for several values
+class UnsafeThreadingException(Exception):
+    pass
+
+
+def _actions_snapshot(actions, update):
+    """Make a list of snapshots from a list of actions."""
+    snapshot = []
+    for action in actions:
+        if hasattr(action, 'snapshot'):
+            snapshot.append(action.snapshot(update=update))
+        else:
+            snapshot.append(_NO_SNAPSHOT)
+    return snapshot
+
+
+class Task:
+    """
+    Execute a function within a measurement Loop, e.g. .each(Task(func, *args, **kwargs)).
+
+    The first argument should be a callable function, to which any subsequent
+    args and kwargs (which are evaluated before the loop starts) are passed.
+
+    e.g.:
+    Define a function to wait for a temperature setpoint to be reached:
+
+    >>> def wait_for_temperature(target_T, measured_T, tolerance):
+    >>>     while abs(measured_T - target_T) > tolerance:
+    >>>         time.sleep(1)
+
+    Then use it in a Loop, inside each, before measuring.
+
+    >>> loop = Loop(temperature_setpoint.sweep(0,2,101),delay=0.1).each(
+    >>>     Task(wait_for_temperature, temperature_setpoint(), temperature(), 0.1),
+    >>>     *station.measure())
+
+    If the args and kwargs are also callable, then they are evaluated
+    before being passed to the func.
+
+    Args:
+        func (callable): Function to executed
+        *args: pass to func, after evaluation if callable
+        **kwargs: pass to func, after evaluation if callable
+
+    """
+    def __init__(self, func, *args, **kwargs):
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, **ignore_kwargs):
+        # If any of the arguments are callable, evaluate them first
+        eval_args = [arg() if callable(arg) else arg for arg in self.args]
+        eval_kwargs = {k: (v() if callable(v) else v) for k, v in self.kwargs.items()}
+
+        self.func(*eval_args, **eval_kwargs)
+
+        return 0 #This seems to stop spurious printing of self.func. Perhaps better way to do this.
+
+    def snapshot(self, update=False):
+        """
+        Snapshots  task
+        Args:
+            update (bool): TODO not in use
+
+        Returns:
+            dict: snapshot
+        """
+        return {'type': 'Task', 'func': repr(self.func)}
+
+
+class Wait:
+    """
+    A simple class to tell a Loop to wait <delay> seconds.
+
+    This is transformed into a Task within the Loop, such that
+    it can do other things (monitor, check for halt) during the delay.
+
+    But for use outside of a Loop, it is also callable (then it just sleeps)
+
+    Args:
+        delay: seconds to delay
+
+    Raises:
+        ValueError: if delay is negative
+    """
+    def __init__(self, delay):
+        if not delay >= 0:
+            raise ValueError('delay must be > 0, not {}'.format(repr(delay)))
+        self.delay = delay
+
+    def __call__(self):
+        if self.delay:
+            time.sleep(self.delay)
+
+    def snapshot(self, update=False):
+        """
+        Snapshots  delay
+        Args:
+            update (bool): TODO not in use
+
+        Returns:
+            dict: snapshot
+        """
+        return {'type': 'Wait', 'delay': self.delay}
+
+
+class _Measure:
+    """
+    A callable collection of parameters to measure.
+
+    This should not be constructed manually, only by an ActiveLoop.
+    """
+    def __init__(self, params_indices, data_set, use_threads):
+        self.use_threads = use_threads and len(params_indices) > 1
+        # the applicable DataSetPP.store function
+        self.store = data_set.store
+
+        # for performance, pre-calculate which params return data for
+        # multiple arrays, and the name mappings
+        self.getters = []
+        self.param_ids = []
+        self.composite = []
+        paramcheck = []  # list to check if parameters are unique
+        for param, action_indices in params_indices:
+            self.getters.append(param.get)
+
+            if param._instrument:
+                paramcheck.append((param, param._instrument))
+
+            if hasattr(param, 'names'):
+                part_ids = []
+                for i in range(len(param.names)):
+                    param_id = data_set.action_id_map[action_indices + (i,)]
+                    part_ids.append(param_id)
+                self.param_ids.append(None)
+                self.composite.append(part_ids)
+            else:
+                param_id = data_set.action_id_map[action_indices]
+                self.param_ids.append(param_id)
+                self.composite.append(False)
+
+        if self.use_threads:
+            insts = [p[1] for p in paramcheck]
+            if (len(set(insts)) != len(insts)):
+                duplicates = [p for p in paramcheck if insts.count(p[1]) > 1]
+                raise UnsafeThreadingException('Can not use threading to '
+                                               'read '
+                                               'several things from the same '
+                                               'instrument. Specifically, you '
+                                               'asked for'
+                                               ' {}.'.format(duplicates))
+
+    def __call__(self, loop_indices, **ignore_kwargs):
+        out_dict = {}
+        if self.use_threads:
+            out = thread_map(self.getters)
+        else:
+            out = [g() for g in self.getters]
+
+        for param_out, param_id, composite in zip(out, self.param_ids,
+                                                  self.composite):
+            if composite:
+                for val, part_id in zip(param_out, composite):
+                    out_dict[part_id] = val
+            else:
+                out_dict[param_id] = param_out
+
+        self.store(loop_indices, out_dict)
+
+
+class _Nest:
+
+    """
+    Wrapper to make a callable nested ActiveLoop.
+
+    This should not be constructed manually, only by an ActiveLoop.
+    """
+
+    def __init__(self, inner_loop, action_indices):
+        self.inner_loop = inner_loop
+        self.action_indices = action_indices
+
+    def __call__(self, **kwargs):
+        self.inner_loop._run_loop(action_indices=self.action_indices, **kwargs)
+
+
+class BreakIf:
+
+    """
+    Loop action that breaks out of the loop if a condition is truthy.
+
+    Args:
+        condition (callable): a callable taking no arguments.
+            Can be a simple function that returns truthy when it's time to quit
+    Raises:
+        TypeError: if condition is not a callable with no aguments.
+
+    Examples:
+            >>> BreakIf(lambda: np.abs(chan1.curr()) >= 3e-9)
+    """
+
+    def __init__(self, condition):
+        if not is_function(condition, 0):
+            raise TypeError('BreakIf condition must be a callable with '
+                            'no arguments')
+        self.condition = condition
+
+    def __call__(self, **ignore_kwargs):
+        if self.condition():
+            raise _QcodesBreak
+
+    def snapshot(self, update=False):
+        """
+        Snapshots breakIf action
+        Args:
+            update (bool): TODO not in use
+
+        Returns:
+            dict: snapshot
+
+        """
+        return {'type': 'BreakIf', 'condition': repr(self.condition)}
+
+class _QcodesBreak(Exception):
+    pass