qkit 0.5.4__tar.gz → 0.7.0__tar.gz

qkit-0.7.0/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on:
+  push:
+    branches: 'master'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.2.2
+        with:
+          fetch-depth: 200
+          fetch-tags: true
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install build dependencies ${{ matrix.python-version }}
+        run: python -m pip install -U hatch hatch-vcs
+      - name: Run tests ${{ matrix.python-version }}
+        run: hatch test --cover-quiet --randomize

{qkit-0.5.4 → qkit-0.7.0}/.gitignore

@@ -32,3 +32,4 @@ notebooks/
 # User install
 qkit_local_config.py
 jupyter_lab_config.py
+launch.bat

{qkit-0.5.4 → qkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.5
 Name: qkit
-Version: 0.5.4
+Version: 0.7.0
 Summary: qKIT quantum measurement suite in python
 Project-URL: Homepage, https://github.com/qkitgroup/qkit
 Project-URL: Bug Tracker, https://github.com/qkitgroup/qkit/issues
@@ -345,14 +345,17 @@ License:                     GNU GENERAL PUBLIC LICENSE
         library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.
         
+License-File: AUTHORS
+License-File: LICENSE
 Keywords: Data Acquisition,Framework,Measurement,Quantum
 Classifier: Framework :: Jupyter :: JupyterLab :: 3
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
-Classifier: Programming Language :: Python :: 3.7
-Requires-Python: >=3.7
-Requires-Dist: filelock>=3.17
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Requires-Dist: filelock>=3.10
 Requires-Dist: h5py>=3.8
+Requires-Dist: importlib-resources; python_version == '3.9' or python_version == '3.10'
 Requires-Dist: ipython
 Requires-Dist: numpy>=1.24
 Requires-Dist: packaging
@@ -377,8 +380,9 @@ Requires-Dist: qgrid>=1.0; extra == 'qgrid'
 Provides-Extra: timedomain
 Requires-Dist: zerorpc>=0.6; extra == 'timedomain'
 Provides-Extra: url
-Requires-Dist: parsita~=2.2.2; extra == 'url'
+Requires-Dist: parsita>=2.0.0; extra == 'url'
 Provides-Extra: zurich-instruments
+Requires-Dist: laboneq-applications>=26.1.0; extra == 'zurich-instruments'
 Requires-Dist: laboneq>=2.59.0; extra == 'zurich-instruments'
 Description-Content-Type: text/markdown
 
@@ -402,7 +406,7 @@ Description-Content-Type: text/markdown
 ### Platform:
   The qkit framework has been tested under windows and with limits under macos x and linux. 
   The gui requires h5py, qt and pyqtgraph, which work fine on these platforms. 
-  The core of the framework should run with python 2.7.x/3.4+
+  The core of the framework should run with python 3.9+
 
 ## Configuration
 There are three sources of configuration, which are used to set up your environment

{qkit-0.5.4 → qkit-0.7.0}/README.md

@@ -18,7 +18,7 @@
 ### Platform:
   The qkit framework has been tested under windows and with limits under macos x and linux. 
   The gui requires h5py, qt and pyqtgraph, which work fine on these platforms. 
-  The core of the framework should run with python 2.7.x/3.4+
+  The core of the framework should run with python 3.9+
 
 ## Configuration
 There are three sources of configuration, which are used to set up your environment

{qkit-0.5.4 → qkit-0.7.0}/pyproject.toml

@@ -12,10 +12,10 @@ authors = [
 description = "qKIT quantum measurement suite in python"
 readme = "README.md"
 license = { file = "LICENSE" }
-requires-python = ">=3.7"
+requires-python = ">=3.11"
 classifiers = [
     "Framework :: Jupyter :: JupyterLab :: 3",
-    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.11",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: GNU General Public License v2 (GPLv2)"
 ]
@@ -32,8 +32,9 @@ dependencies = [
     "tomli>=2.0.1",
     "ipython",
     "packaging",
-    "filelock>=3.17",
-    "tqdm>=4.67.0"
+    "filelock>=3.10",
+    "tqdm>=4.67.0",
+    "importlib_resources; python_version == '3.9' or python_version == '3.10'"
 ]
 
 [project.scripts]
@@ -49,7 +50,8 @@ jupyter = [
     "ipywidgets>=8.0"
 ]
 zurich-instruments = [
-    "LabOneQ>=2.59.0"
+    "LabOneQ>=2.59.0",
+    "laboneq-applications>=26.1.0"
 ]
 analysis = [
     "matplotlib>=3.7",
@@ -63,7 +65,7 @@ timedomain = [
     "zerorpc>=0.6"
 ]
 url = [
-    "parsita~=2.2.2"
+    "parsita>=2.0.0"
 ]
 
 
@@ -92,7 +94,7 @@ exclude = ["data/*", "notebooks/*", "logs/*", "venv/*"]
 
 [tool.hatch.envs.hatch-test]
 extra-dependencies = [
-    "parsita~=2.2.2"
+    "parsita>=2.0.0"
 ]
 
 [tool.pytest.ini_options]

qkit-0.7.0/src/qkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

qkit-0.7.0/src/qkit/analysis/ZIPowerFromAmplitude.py

@@ -0,0 +1,78 @@
+import numpy as np
+
+from qkit.measure.unified_measurements import AnalysisTypeAdapter, MeasurementTypeAdapter, DataView, Axis
+from qkit.measure.laboneq_measurement import LabOneQMeasurement
+
+
+class ZIPowerFromAmplitude(AnalysisTypeAdapter):
+    """
+    An analysis converting the amplitude measurements and axis returned by Zurich Instruments devices into powers (dBm).
+
+    Our other devices usually return power, and most people are used to seeing and working with decibels.
+    """
+
+    _convert_datasets: dict[str, str] = None
+    _convert_axes: dict[str, str] = None
+    _generated_datasets: dict[str, MeasurementTypeAdapter.DataDescriptor] = None
+
+    def __init__(self, output_range: float, convert_datasets: None | dict[str, str] = None, convert_axes: None | dict[str, str] = None):
+        self._convert_datasets = convert_datasets
+        self._convert_axes = convert_axes
+        self._output_range = output_range
+
+    def _should_convert_dataset(self, schema: 'MeasurementTypeAdapter.DataDescriptor') -> bool:
+        if self._convert_datasets is None:
+            return schema.name.endswith("_mag")
+        else:
+            return schema.name in self._convert_datasets
+
+    def _map_dataset_name(self, schema: 'MeasurementTypeAdapter.DataDescriptor') -> str:
+        assert self._should_convert_dataset(schema)
+        if self._convert_datasets is None:
+            return schema.name.replace("_mag", "_power")
+        else:
+            return self._convert_datasets[schema.name]
+
+    def _should_convert_axis(self, axis: Axis) -> bool:
+        if self._convert_axes is None:
+            return axis.name.startswith("amplitudes")
+        else:
+            return axis.name in self._convert_axes
+
+    def _map_axis_name(self, axis: Axis) -> str:
+        assert self._should_convert_axis(axis)
+        if self._convert_axes is None:
+            return axis.name.replace("amplitudes", "powers")
+        else:
+            return self._convert_axes[axis.name]
+
+    @staticmethod
+    def amplitude_to_power(amplitudes: np.ndarray) -> np.ndarray:
+        return 30 + 20 * np.log10(amplitudes) # Power at 50 Ohm impedance, amplitudes in Volts, dBm
+
+    def _map_axes(self, axes: tuple[Axis, ...]) -> tuple[Axis, ...]:
+        return tuple(
+            Axis(self._map_axis_name(a), LabOneQMeasurement.calculate_powers(a.range, self._output_range), 'dBm') if self._should_convert_axis(a) else a
+            for a in axes
+        )
+
+    def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple[
+        'MeasurementTypeAdapter.DataDescriptor', ...]:
+        self._generated_datasets: dict[str, MeasurementTypeAdapter.DataDescriptor] = {
+            schema.name: MeasurementTypeAdapter.DataDescriptor(self._map_dataset_name(schema), self._map_axes(schema.axes), "dBm?", schema.category)
+            for schema in parent_schema if self._should_convert_dataset(schema)
+        }
+        return tuple(self._generated_datasets.values())
+
+    def default_views(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> dict[
+        str, "DataView"]:
+        # We don't add any additional views.
+        return dict()
+
+    def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
+        'MeasurementTypeAdapter.GeneratedData', ...]:
+        return tuple(
+            self._generated_datasets[datum.descriptor.name].with_data(self.amplitude_to_power(datum.data))
+            for datum in data if datum.descriptor.name in self._generated_datasets
+        )
+

qkit-0.7.0/src/qkit/analysis/circle_fit/circlefit_analysis.py

@@ -0,0 +1,157 @@
+import numpy as np
+
+from qkit.analysis.circle_fit.circle_fit_2019.circuit import circuit, reflection_port, notch_port
+from qkit.measure.unified_measurements import AnalysisTypeAdapter, MeasurementTypeAdapter, DataView, DataViewSet, \
+    DataReference
+
+
+class CircleFitAnalysis(AnalysisTypeAdapter):
+    """
+    Perform circle fit analysis on a spectroscopy measurement.
+    """
+
+    def __init__(self, ports = 2, amplitude_tag = 'amp', phase_tag = 'phase', autocorrect = False):
+        self._ports = ports
+        self._amplitude_tag = amplitude_tag
+        self._phase_tag = phase_tag
+        self._autocorrect = autocorrect
+
+    def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple[
+        'MeasurementTypeAdapter.DataDescriptor', ...]:
+        """
+        We expect the synthesized circle (real and imag) and the fit parameters.
+        """
+        frequency_axis = parent_schema[0].axes
+        return (
+            MeasurementTypeAdapter.DataDescriptor("real", frequency_axis, "real", "data"),
+            MeasurementTypeAdapter.DataDescriptor("imag", frequency_axis, "imag", "data"),
+            MeasurementTypeAdapter.DataDescriptor("fit_real", frequency_axis, "mag", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("fit_imag", frequency_axis, "imag", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("fit_mag", frequency_axis, "mag", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("fit_phase", frequency_axis, "rad", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_c", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_c_abs", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_c_min", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_c_max", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_i", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_i_min", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_i_max", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_i_no_dia_corr", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("q_l", (), "", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("a", (), "mag", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("alpha", (), "rad", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("delay", (), "s", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("delay_remaining", (), "s", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("f_res", (), "Hz", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("phi", (), "rad", "analysis"),
+            MeasurementTypeAdapter.DataDescriptor("theta", (), "rad", "analysis"),
+        )
+
+    def default_views(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> dict[
+        str, "DataView"]:
+        frequency = parent_schema[0].axes[0]
+        parent_amp_name = [entry.name for entry in parent_schema if self._amplitude_tag in entry.name][0]
+        parent_phase_name = [entry.name for entry in parent_schema if self._phase_tag in entry.name][0]
+        return {
+            "circle_fit": DataView(
+                view_params={
+                    "labels": ("real", "imag"),
+                    "plot_style": 1,
+                    "markersize": 5,
+                    "aspect": 1.0
+                },
+                view_sets=[
+                    DataViewSet( # Real data
+                        x_path=DataReference("real", category='data'),
+                        y_path=DataReference("imag", category='data'),
+                    ),
+                    DataViewSet( # Fit result
+                        x_path=DataReference("fit_real", category='analysis'),
+                        y_path=DataReference("fit_imag", category='analysis')
+                    )
+                ]
+            ),
+            "phase_fit": DataView(
+                view_params={
+                    "labels": ("frequency", "phase"),
+                    "plot_style": 1,
+                    "markersize": 5
+                },
+                view_sets=[
+                    DataViewSet(
+                        x_path=DataReference(frequency.name),
+                        y_path=DataReference(parent_phase_name)
+                    ),
+                    DataViewSet(
+                        x_path=DataReference(frequency.name),
+                        y_path=DataReference("fit_phase", category='analysis')
+                    )
+                ]
+            ),
+            "mag_fit": DataView(
+                view_params={
+                    "labels": ("frequency", "mag"),
+                    "plot_style": 1,
+                    "markersize": 5
+                },
+                view_sets=[
+                    DataViewSet(
+                        x_path=DataReference(frequency.name),
+                        y_path=DataReference(parent_amp_name)
+                    ),
+                    DataViewSet(
+                        x_path=DataReference(frequency.name),
+                        y_path=DataReference("fit_mag", category='analysis')
+                    )
+                ]
+            )
+        }
+
+    def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
+        'MeasurementTypeAdapter.GeneratedData', ...]:
+        amp_data = [datum for datum in data if self._amplitude_tag in datum.descriptor.name][0]
+        phase_data = [datum for datum in data if self._phase_tag in datum.descriptor.name][0]
+
+        frequencies = amp_data.descriptor.axes[0].range
+        amplitudes = amp_data.data
+        # Unwrap and linearly correct data
+        if self._autocorrect:
+            unwrapped = np.unwrap(phase_data.data)
+            phases = unwrapped - np.nan_to_num(np.linspace(unwrapped[0], unwrapped[-1], len(unwrapped)))
+        else:
+            phases = phase_data.data
+        z_data = amplitudes * np.exp(1j * phases)
+
+        # precompute for storage later.
+        imag = np.imag(z_data)
+        real = np.real(z_data)
+
+        # Perform the fit
+        if self._ports == 1:
+            fit: circuit = reflection_port(frequencies, z_data)
+        elif self._ports == 2:
+            fit: circuit = notch_port(frequencies, z_data)
+        else:
+            raise NotImplemented
+        fit.autofit()
+
+        results = [
+            real, imag, # Converted measured data
+            fit.z_data_sim.real, fit.z_data_sim.imag, np.abs(fit.z_data_sim), np.angle(fit.z_data_sim), # Fitted data
+            # The fit parameters
+            # Quality factors
+            fit.Qc, fit.absQc, fit.Qc_min, fit.Qc_max,
+            fit.Qi, fit.Qi_min, fit.Qi_max, fit.Qi_no_dia_corr,
+            fit.Ql,
+            # Center parameters
+            fit.a, fit.alpha,
+            # Delay
+            fit.delay, fit.delay_remaining,
+            # Misc
+            fit.fr,
+            fit.phi, fit.theta,
+        ]
+
+        declared_shape = self.expected_structure(tuple(datum.descriptor for datum in data))
+        return tuple(desc.with_data(data) for desc, data in zip(declared_shape, results))
+

qkit-0.7.0/src/qkit/analysis/fit_analysis_adapter.py

@@ -0,0 +1,70 @@
+from collections import namedtuple
+from typing import Callable, Union
+
+import numpy as np
+
+from qkit.measure.unified_measurements import AnalysisTypeAdapter, DataGenerator, MeasurementTypeAdapter, DataView, \
+    DataViewSet, DataReference
+from scipy.optimize import curve_fit
+
+FitParam = namedtuple('FitParam', ['name', 'init_value', 'unit'])
+
+class FitAnalysisAdapter(AnalysisTypeAdapter):
+
+    def __init__(self, fit_function: Callable, dataset_phrase: str,
+                 p0: Union[tuple[FitParam, ...], Callable[[np.ndarray, np.ndarray], tuple[FitParam, ...]]],
+                 post_hook: Union[Callable, None] = None, fit_name: str = 'fit_curve'):
+        self.synth_desc = None
+        self.fit_function = fit_function
+        self.dataset_phrase = dataset_phrase
+        self.p0 = p0
+        self.post_hook = post_hook
+        self.fit_name = fit_name
+        example_p0 = self.p0(np.linspace(0, 100, 100), np.ones(100)) if callable(self.p0) else self.p0
+        self.structure = tuple(
+            DataGenerator.DataDescriptor(name=param.name, unit=param.unit, axes=tuple(), category='analysis')
+            for param in example_p0
+        )
+
+    def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple[
+        'MeasurementTypeAdapter.DataDescriptor', ...]:
+        relevant_descriptor = [desc for desc in parent_schema if self.dataset_phrase in desc.name][0]
+        self.synth_desc = DataGenerator.DataDescriptor(name=self.fit_name, unit=relevant_descriptor.unit, axes=relevant_descriptor.axes, category='analysis')
+        return self.structure + (self.synth_desc,)
+
+    def default_views(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> dict[str, "DataView"]:
+        relevant_descriptor = [desc for desc in parent_schema if self.dataset_phrase in desc.name][0]
+        x_axis = relevant_descriptor.axes[0]
+        return {
+            'fit': DataView(
+                view_params= {
+                    "plot_style": 1,
+                    "markersize": 5
+                },
+                view_sets=[
+                    DataViewSet(# Real Data
+                        x_path=DataReference(x_axis.name),
+                        y_path=DataReference(relevant_descriptor.name),
+                    ),
+                    DataViewSet(# Fit Curve
+                        x_path=DataReference(x_axis.name),
+                        y_path=DataReference(self.fit_name, 'analysis'),
+                    )
+                ]
+            )
+        }
+
+    def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
+        'MeasurementTypeAdapter.GeneratedData', ...]:
+        relevant_data = [datum for datum in data if self.dataset_phrase in datum.descriptor.name][0]
+        x = relevant_data.descriptor.axes[0].range
+        y = relevant_data.data
+
+        start_params = self.p0(x, y) if callable(self.p0) else self.p0
+        popt, pcov = curve_fit(self.fit_function, x, y, p0=tuple(param.init_value for param in start_params))
+        self.post_hook(popt, pcov)
+        synthetic_data = self.fit_function(x, *popt)
+        return tuple(
+            desc.with_data(opt_param)
+            for (desc, opt_param) in zip(self.structure, popt)
+        ) + (self.synth_desc.with_data(synthetic_data),)

{qkit-0.5.4 → qkit-0.7.0}/src/qkit/analysis/numerical_derivative.py

@@ -1,5 +1,4 @@
 import itertools
-from typing import override
 
 from scipy import signal
 
@@ -26,7 +25,6 @@ class SavgolNumericalDerivative(AnalysisTypeAdapter):
         self._polyorder = polyorder
         self._derivative = derivative
 
-    @override
     def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
         'MeasurementTypeAdapter.GeneratedData', ...]:
         parent_schema = tuple([element.descriptor for element in data])
@@ -44,7 +42,6 @@ class SavgolNumericalDerivative(AnalysisTypeAdapter):
         return tuple(out)
 
 
-    @override
     def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple['MeasurementTypeAdapter.DataDescriptor', ...]:
         structure = []
         for (x, y) in itertools.batched(parent_schema, 2):
@@ -65,7 +62,6 @@ class SavgolNumericalDerivative(AnalysisTypeAdapter):
             ]
         return tuple(structure)
 
-    @override
     def default_views(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> dict[str, DataView]:
         schema = self.expected_structure(parent_schema)
         variable_names = (schema[0].name.split('_')[0], schema[1].name.split('_')[0])

{qkit-0.5.4 → qkit-0.7.0}/src/qkit/analysis/qfit.py

@@ -363,18 +363,23 @@ class QFIT(object):
                         return
             
         else:   #use specified entries
-            entrytypes = self.hf['/entry/'].keys()
-            try: entrytypes.remove('views')
-            except (ValueError,AttributeError): pass
-            for et in entrytypes:
-                for e in entries:
-                    for k in self.hf['/entry/'+et].keys():
+            for entry in entries:
+                if entry.startswith('/'):
+                    # This is an absolute path, just take it.
+                    urls.append(entry)
+                else:
+                    # This is a relative path, and likely an implicit reference to /entry/data0/...
+                    # We need to search for it.
+                    for category in self.hf['/entry/'].keys():
+                        if category == 'views':
+                            continue
+                        path_candidate = '/entry/' + category + '/' + entry
                         try:
-                            if e == et+k or (e == k and et == 'data0'):
-                                urls.append('/entry/'+et+'/'+k)
-                        except IndexError:
-                            logging.error('Entries cannot be identified. No data for >> {:s} << found. Aborting.'.format(str(e)))
-                            return
+                            self.hf[path_candidate]
+                            urls.append(path_candidate)
+                            break
+                        except KeyError:
+                            pass
 
         self.hf.close()                
         #cast to real strings in case the urls ended up to be unicode

qkit-0.7.0/src/qkit/analysis/rabi_peak_tracker.py

@@ -0,0 +1,27 @@
+from typing import Callable
+
+import numpy as np
+
+from qkit.measure.unified_measurements import AnalysisTypeAdapter, MeasurementTypeAdapter
+
+
+class RabiPeakTracker(AnalysisTypeAdapter):
+
+    def __init__(self, dataset_phrase : str, post_hook: Callable[[float], None]) -> None:
+        self.dataset_phrase = dataset_phrase
+        self.post_hook = post_hook
+        self.result_descriptor = MeasurementTypeAdapter.DataDescriptor("rabi_peak", tuple(), unit='Hz', category='analysis')
+
+    def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple[
+        'MeasurementTypeAdapter.DataDescriptor', ...]:
+        return (self.result_descriptor,)
+
+    def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
+        'MeasurementTypeAdapter.GeneratedData', ...]:
+        data = [datum for datum in data if self.dataset_phrase in datum.descriptor.name][0]
+        x_axis = data.descriptor.axes[0].range
+        signal_strength = np.std(data.data, axis=-1)
+        maximum_frequency = x_axis[np.argmax(signal_strength)]
+        self.post_hook(maximum_frequency)
+        return (self.result_descriptor.with_data(maximum_frequency),)
+

{qkit-0.5.4 → qkit-0.7.0}/src/qkit/core/instrument_base.py

@@ -624,6 +624,7 @@ class Instrument(object):
             bool: bool,
             tuple: tuple,
             list: list,
+            dict: dict,
             np.ndarray: lambda x: x.tolist(),
     }
 

{qkit-0.5.4 → qkit-0.7.0}/src/qkit/core/instrument_tools.py

@@ -70,7 +70,9 @@ class Insttools(object):
         self._user_instdir  = qkit.cfg.get('user_instruments_dir')
         lookup_dict_location = qkit.cfg.get('device_lookup_config')
         if lookup_dict_location is not None:
-            self._lookup_dict = tomli.load(lookup_dict_location)
+            logging.info(f"Loading devices configuration from {lookup_dict_location}")
+            with open(lookup_dict_location, "rb") as f:
+                self._lookup_dict = tomli.load(f)
         else:
             self._lookup_dict = {}
 
@@ -264,14 +266,14 @@ class Insttools(object):
                 f.write(descr)
         return self.get(name)
 
-    def create_from_config(self, name, **kwargs):
+    def create_from_config(self, identifier, registered_name, **kwargs):
         """
-        Check in the local config file for the device name. If it exists, take the config from there to create the device.
+        Check in the local config file for the device name `registered_name`. If it exists, take the config from there to create the device.
         
         Override with values from keyword arguments.
         """
         # This merges the configuration dict with
-        config = {**self._lookup_dict[name], **kwargs, 'name': name}
+        config = {**self._lookup_dict[registered_name], **kwargs, 'name': identifier}
         return self.create(**config)
 
 

{qkit-0.5.4 → qkit-0.7.0}/src/qkit/core/s_init/S70_load_visa.py

@@ -4,7 +4,6 @@
 """
 import qkit
 import logging
-from pkgutil import find_loader
 
 
 def _load_visa():

qkit-0.7.0/src/qkit/drivers/ZISetup.py

@@ -0,0 +1,44 @@
+import logging
+from types import NoneType
+
+from laboneq.dsl.device import DeviceSetup
+from laboneq.dsl.quantum import QPU, QuantumParameters
+from laboneq.dsl.quantum.quantum_element import AttrDict, QuantumElement
+from laboneq.dsl.session import Session
+from laboneq_applications.qpu_types.tunable_transmon import TunableTransmonQubit, TunableTransmonOperations
+
+from qkit.core.instrument_base import Instrument
+
+
+class ZISetup(Instrument):
+
+    def __init__(self, name: str, address: str, descriptor, **kwargs):
+        super().__init__(name, **kwargs)
+        self._setup = DeviceSetup.from_descriptor(descriptor, address)
+        self._session = Session(self._setup, log_level=logging.WARNING)
+        self._session.connect(reset_devices=True)
+        self._qubits = TunableTransmonQubit.from_device_setup(self._setup)
+
+        # Register parameters for each qubit.
+        parameters: QuantumParameters = self._qubits[0].parameters
+        attributes = [entry for entry in dir(parameters) if not entry.startswith('_') and not callable(getattr(parameters, entry))]
+        for key in attributes:
+            inferred_type = type(getattr(parameters, key))
+            if inferred_type is int:
+                inferred_type = float
+            if inferred_type is AttrDict:
+                inferred_type = dict
+            elif inferred_type is NoneType:
+                inferred_type = float
+            self.add_parameter(key, channels=(0, len(self._qubits)-1), type=inferred_type, flags=Instrument.FLAG_GETSET,
+                               get_func=lambda channel, _key=key: getattr(self.get_qubit(channel).parameters, _key),
+                               set_func=lambda value, channel, _key=key: setattr(self.get_qubit(channel).parameters, _key, value))
+
+    def get_qpu(self) -> QPU:
+        return QPU(self._qubits, quantum_operations=TunableTransmonOperations())
+
+    def get_qubit(self, index: int) -> QuantumElement:
+        return self._qubits[index]
+
+    def get_session(self):
+        return self._session