qcodes 0.45.0__tar.gz → 0.46.0__tar.gz

{qcodes-0.45.0/src/qcodes.egg-info → qcodes-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qcodes
-Version: 0.45.0
+Version: 0.46.0
 Summary: Python-based data acquisition framework developed by the Copenhagen / Delft / Sydney / Microsoft quantum computing consortium
 Maintainer-email: QCoDeS Core Developers <qcodes-support@microsoft.com>
 License: MIT
@@ -78,6 +78,7 @@ Requires-Dist: types-tqdm>=4.64.6; extra == "test"
 Requires-Dist: types_pywin32>=305.0.0.7; extra == "test"
 Requires-Dist: qcodes_loop>=0.1.1; extra == "test"
 Requires-Dist: zhinst.qcodes>=0.5; extra == "test"
+Requires-Dist: libcst>=1.2.0; extra == "test"
 Requires-Dist: jinja2>=3.1.3; extra == "test"
 Provides-Extra: docs
 Requires-Dist: autodocsumm>=0.2.9; extra == "docs"
@@ -96,6 +97,8 @@ Requires-Dist: jinja2>=3.1.3; extra == "docs"
 Provides-Extra: opencensus
 Requires-Dist: opencensus>=0.7.10; extra == "opencensus"
 Requires-Dist: opencensus-ext-azure<2.0.0,>=1.0.4; extra == "opencensus"
+Provides-Extra: refactor
+Requires-Dist: libcst>=1.2.0; extra == "refactor"
 
 QCoDeS |PyPi| |DOCS| |PyPI python versions| |DOI|
 =================================================

{qcodes-0.45.0 → qcodes-0.46.0}/pyproject.toml

@@ -98,6 +98,7 @@ test = [
     "types_pywin32>=305.0.0.7",
     "qcodes_loop>=0.1.1",
     "zhinst.qcodes>=0.5", # typecheck zhinst driver alias
+    "libcst>=1.2.0", # refactor tests
     "jinja2>=3.1.3", # transitive dependency pin due to cve in earlier version
 ]
 docs = [
@@ -119,9 +120,13 @@ opencensus = [
     "opencensus>=0.7.10",
     "opencensus-ext-azure>=1.0.4, <2.0.0",
 ]
+refactor = [
+    "libcst>=1.2.0"
+]
 
 [project.scripts]
 qcodes-monitor = "qcodes.monitor.monitor:main"
+qcodes-refactor = "qcodes.extensions._refactor:main"
 qcodes-dynacool-server = "qcodes.instrument_drivers.QuantumDesign.DynaCoolPPMS.private.server:run_server"
 
 [project.entry-points."qcodes.dataset.on_export"]
@@ -203,7 +208,7 @@ module = [
 ignore_missing_imports = true
 
 [tool.pyright]
-include = ["src"]
+include = ["src","tests"]
 ignore = [
     "src/qcodes/instrument_drivers/Harvard/Decadac.py",
     ]
@@ -223,7 +228,9 @@ markers = "serial"
 
 # we ignore warnings
 # triggered by third party packages
+# and error on all other warnings
 filterwarnings = [
+    'error',
     'ignore:Deprecated call to `pkg_resources\.declare_namespace:DeprecationWarning',  # google, sphinxcontrib
     'ignore:pkg_resources is deprecated as an API:DeprecationWarning', # pyvisa-sim
     'ignore:open_binary is deprecated:DeprecationWarning', # pyvisa-sim

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/_version.py

@@ -14,4 +14,4 @@ def _get_version() -> str:
         return "0.0"
 
 
-__version__ = "0.45.0"
+__version__ = "0.46.0"

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/dataset/dond/do_nd_utils.py

@@ -120,14 +120,26 @@ def _register_actions(
 
 
 @contextmanager
-def catch_interrupts() -> Iterator[Callable[[], MeasInterruptT]]:
-    interrupt_exception = None
+def catch_interrupts() -> Iterator[Callable[[], MeasInterruptT | None]]:
+    interrupt_exception: MeasInterruptT | None = None
+    interrupt_raised = False
 
-    def get_interrupt_exception() -> MeasInterruptT:
+    def get_interrupt_exception() -> MeasInterruptT | None:
         nonlocal interrupt_exception
         return interrupt_exception
 
     try:
         yield get_interrupt_exception
-    except (KeyboardInterrupt, BreakConditionInterrupt) as e:
+    except KeyboardInterrupt as e:
         interrupt_exception = e
+        interrupt_raised = True
+        raise  # Re-raise KeyboardInterrupt
+    except BreakConditionInterrupt as e:
+        interrupt_exception = e
+        interrupt_raised = True
+        # Don't re-raise BreakConditionInterrupt
+    finally:
+        if interrupt_raised:
+            log.warning(
+                f"Measurement has been interrupted, data may be incomplete: {interrupt_exception}"
+            )

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/dataset/measurements.py

@@ -932,6 +932,12 @@ class Measurement:
                 f"{ParamSpec.allowed_types} are supported."
             )
 
+        if setpoints is not None:
+            self._check_setpoints_type(setpoints, "setpoints")
+
+        if basis is not None:
+            self._check_setpoints_type(basis, "basis")
+
         if isinstance(parameter, ArrayParameter):
             self._register_arrayparameter(parameter, setpoints, basis, paramtype)
         elif isinstance(parameter, ParameterWithSetpoints):
@@ -970,6 +976,18 @@ class Measurement:
 
         return self
 
+    @staticmethod
+    def _check_setpoints_type(arg: setpoints_type, name: str) -> None:
+        if (
+            not isinstance(arg, Sequence)
+            or isinstance(arg, str)
+            or any(not isinstance(a, (str, ParameterBase)) for a in arg)
+        ):
+            raise TypeError(
+                f"{name} should be a sequence of str or ParameterBase, not "
+                f"{type(arg)}"
+            )
+
     @staticmethod
     def _infer_paramtype(parameter: ParameterBase, paramtype: str | None) -> str | None:
         """

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/dataset/plotting.py

@@ -2,6 +2,7 @@
 This plotting module provides various functions to plot the data measured
 using QCoDeS.
 """
+
 from __future__ import annotations
 
 import inspect
@@ -236,7 +237,6 @@ def plot_dataset(
     new_colorbars: list[Colorbar | None] = []
 
     for data, ax, colorbar in zip(alldata, axeslist, colorbars):
-
         if len(data) == 2:  # 1D PLOTTING
             log.debug(f"Doing a 1D plot with kwargs: {kwargs}")
 
@@ -330,7 +330,11 @@ def plot_dataset(
 
 def plot_and_save_image(
     data: DataSetProtocol, save_pdf: bool = True, save_png: bool = True
-) -> tuple[DataSetProtocol, tuple[Axes, ...], tuple[Colorbar | None, ...],]:
+) -> tuple[
+    DataSetProtocol,
+    tuple[Axes, ...],
+    tuple[Colorbar | None, ...],
+]:
     """
     The utility function to plot results and save the figures either in pdf or
     png or both formats.
@@ -578,7 +582,6 @@ def plot_2d_scatterplot(
         The matplotlib axis handles for plot and colorbar
     """
     import matplotlib
-    import matplotlib.cm
 
     if "rasterized" in kwargs.keys():
         rasterized = kwargs.pop("rasterized")
@@ -597,7 +600,7 @@ def plot_2d_scatterplot(
 
     if z_is_stringy:
         name = getattr(cmap, "name", _DEFAULT_COLORMAP)
-        cmap = matplotlib.cm.get_cmap(name, len(z_strings))
+        cmap = matplotlib.colormaps.get_cmap(name).resampled(len(z_strings))
 
     # according to the docs the c argument should support an ndarray
     # but that fails type checking
@@ -649,7 +652,6 @@ def plot_on_a_plain_grid(
         The matplotlib axes handle for plot and colorbar
     """
     import matplotlib
-    import matplotlib.cm
 
     log.debug(f"Got kwargs: {kwargs}")
 
@@ -698,7 +700,7 @@ def plot_on_a_plain_grid(
 
     if z_is_stringy:
         name = getattr(cmap, "name", _DEFAULT_COLORMAP)
-        cmap = matplotlib.cm.get_cmap(name, len(z_strings))
+        cmap = matplotlib.colormaps.get_cmap(name).resampled(len(z_strings))
 
     colormesh = ax.pcolormesh(
         x_to_plot,

qcodes-0.46.0/src/qcodes/extensions/_refactor.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import argparse
+import os
+from dataclasses import dataclass
+from glob import glob
+from pathlib import Path
+from textwrap import dedent
+from typing import Union, cast
+
+try:
+    import libcst as cst
+    from libcst import matchers as m
+    from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+except ImportError as er:
+    raise ImportError(
+        "qcodes-refactor requires that QCoDeS is installed with refactor extra dependencies."
+    ) from er
+
+
+@dataclass
+class Extracted:
+    name: str | None = None
+    docstring: str | None = None
+    parameter_class: str | None = None
+
+
+class AddParameterTransformer(VisitorBasedCodemodCommand):
+    """
+    This is a tool that will transform `self.add_parameter("name", ...)`
+    into the form `self.name: Parameter = self.add_parameter("name", ...)`
+    as well as as add a docstring either by extracting the docstring arg
+    from add_parameter or by generating a generic docstring.
+    This enabled parameters to be typechecked and documented
+    """
+
+    def __init__(self, context: CodemodContext) -> None:
+        self.annotations: Extracted = Extracted()
+        self._arg_num: dict[str, int] = {}
+        self._call_stack: list[str] = []
+        super().__init__(context=context)
+
+    def visit_Call(self, node: cst.Call) -> None:
+        call_name = _get_call_name(node)
+        if call_name is not None:
+            self._call_stack.append(call_name)
+            self._arg_num[call_name] = 0
+
+    def visit_Arg(self, node: cst.Arg) -> None:
+        if len(self._call_stack) == 0:
+            return
+        self._arg_num[self._call_stack[-1]] += 1
+        if self._call_stack[-1] != "self.add_parameter":
+            return
+
+        first_positional_arg_is_str = self._arg_num[
+            self._call_stack[-1]
+        ] == 1 and m.matches(
+            node,
+            matcher=m.Arg(value=m.SimpleString(), keyword=None),
+        )
+        arg_is_name = m.matches(
+            node, m.Arg(keyword=m.Name(value="name"), value=m.SimpleString())
+        )
+
+        arg_is_docstring = m.matches(
+            node,
+            matcher=m.Arg(
+                keyword=m.Name(value="docstring"),
+                value=m.OneOf(m.SimpleString(), m.ConcatenatedString()),
+            ),
+        )
+
+        arg_is_docstring_dedent = m.matches(
+            node,
+            m.Arg(
+                keyword=m.Name(value="docstring"),
+                value=m.Call(args=[m.Arg(m.SimpleString())]),
+            ),
+        )
+
+        arg_is_parameter_class = m.matches(
+            node,
+            matcher=m.Arg(keyword=m.Name(value="parameter_class"), value=m.Name()),
+        )
+
+        second_positional_arg_is_str = self._arg_num[
+            self._call_stack[-1]
+        ] == 2 and m.matches(
+            node,
+            matcher=m.Arg(value=m.Name(), keyword=None),
+        )
+
+        if first_positional_arg_is_str or arg_is_name:
+            self.annotations.name = cst.ensure_type(
+                node.value, cst.SimpleString
+            ).raw_value
+
+        if arg_is_docstring:
+            self.annotations.docstring = str(
+                cast(
+                    Union[cst.SimpleString, cst.ConcatenatedString], node.value
+                ).evaluated_value
+            )
+        if arg_is_docstring_dedent:
+            self.annotations.docstring = dedent(
+                str(
+                    cst.ensure_type(
+                        cst.ensure_type(node.value, cst.Call).args[0].value,
+                        cst.SimpleString,
+                    ).evaluated_value
+                )
+            ).strip()
+
+        if arg_is_parameter_class or second_positional_arg_is_str:
+            self.annotations.parameter_class = cst.ensure_type(
+                node.value, cst.Name
+            ).value
+
+    def leave_Call(self, original_node: cst.Call, updated_node: cst.Call) -> cst.Call:
+        call_name = _get_call_name(updated_node)
+        if call_name is not None:
+            self._call_stack.pop()
+        return updated_node
+
+    def leave_SimpleStatementLine(
+        self,
+        original_node: cst.SimpleStatementLine,
+        updated_node: cst.SimpleStatementLine,
+    ) -> cst.FlattenSentinel | cst.SimpleStatementLine:
+        annotations = self.annotations
+        self.annotations = Extracted()
+
+        if not m.matches(
+            updated_node.body[0],
+            m.Expr(value=m.Call(func=m.Attribute(attr=m.Name("add_parameter")))),
+        ):
+            return updated_node
+
+        call_node = cst.ensure_type(
+            cst.ensure_type(updated_node.body[0], cst.Expr).value, cst.Call
+        )
+
+        if annotations.name is None:
+            return updated_node
+
+        if annotations.parameter_class is not None:
+            parameter_class = annotations.parameter_class
+        else:
+            parameter_class = "Parameter"
+
+        if annotations.docstring is not None:
+            comment = cst.parse_module(f'"""{annotations.docstring}"""')
+        else:
+            comment = cst.parse_module(f'"""Parameter {annotations.name}"""')
+
+        stm = cst.parse_statement(
+            source=f"self.{annotations.name}: {parameter_class} = x"
+        )
+
+        if isinstance(stm.body, cst.BaseSuite) or isinstance(
+            comment.body, cst.BaseSuite
+        ):
+            raise RuntimeError("Unexpected result from parsing code.")
+
+        new_node = stm.body[0]
+        new_node = new_node.with_changes(value=call_node)
+
+        return cst.FlattenSentinel(
+            [updated_node.with_changes(body=[new_node]), comment.body[0]]
+        )
+
+
+def transform_files_in_folder(folder_path: Path) -> None:
+    transformer = AddParameterTransformer(CodemodContext())
+    files = glob(f"{folder_path}/**/*.py", recursive=True)
+    for filename in files:
+        if filename.endswith(".py"):
+            try:
+                file_name: str = os.path.join(folder_path, filename)
+                with open(file_name, encoding="utf-8") as file:
+                    source_code = file.read()
+                source_tree = cst.parse_module(source_code)
+                modified_tree = source_tree.visit(transformer)
+                if source_tree.code != modified_tree.code:
+                    with open(file_name, "w", encoding="utf-8") as file:
+                        print(f"Modified {file_name}")
+                        file.write(modified_tree.code)
+            except Exception as ex:
+                print(f"could not parse {filename}. Got {ex}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="QCoDeS refactor tool",
+        description="Perform refactors related to QCoDeS.",
+    )
+    choices = ["parameter_refactor"]
+
+    parser.add_argument("tool", choices=choices, help="Refactor tool to run.")
+    parser.add_argument(
+        "path", help="Path to folder where the transform should be run."
+    )
+
+    args = parser.parse_args()
+
+    if args.tool == choices[0]:
+        path = Path(args.path).absolute()
+        transform_files_in_folder(folder_path=path)
+
+
+def _get_call_name(node: cst.Call) -> str | None:
+    if m.matches(node.func, m.Attribute(value=m.Name(), attr=m.Name())):
+        my_class = cst.ensure_type(
+            cst.ensure_type(node.func, cst.Attribute).value, cst.Name
+        ).value
+        my_attr = cst.ensure_type(
+            cst.ensure_type(node.func, cst.Attribute).attr, cst.Name
+        ).value
+
+        func_name = f"{my_class}.{my_attr}"
+    elif m.matches(node.func, m.Name()):
+        func_name = cst.ensure_type(node.func, cst.Name).value
+    else:
+        return None
+
+    return func_name

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/instrument/__init__.py

@@ -17,9 +17,9 @@ from qcodes.parameters import (  # noqa: F401
 
 from .channel import ChannelList, ChannelTuple, InstrumentChannel, InstrumentModule
 from .instrument import Instrument, find_or_create_instrument
-from .instrument_base import InstrumentBase
+from .instrument_base import InstrumentBase, InstrumentBaseKWArgs
 from .ip import IPInstrument
-from .visa import VisaInstrument
+from .visa import VisaInstrument, VisaInstrumentKWArgs
 
 __all__ = [
     "ChannelList",
@@ -27,8 +27,10 @@ __all__ = [
     "IPInstrument",
     "Instrument",
     "InstrumentBase",
+    "InstrumentBaseKWArgs",
     "InstrumentChannel",
     "InstrumentModule",
     "VisaInstrument",
+    "VisaInstrumentKWArgs",
     "find_or_create_instrument",
 ]

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/instrument/channel.py

@@ -19,7 +19,10 @@ from qcodes.validators import Validator
 from .instrument_base import InstrumentBase
 
 if TYPE_CHECKING:
+    from typing_extensions import Unpack
+
     from .instrument import Instrument
+    from .instrument_base import InstrumentBaseKWArgs
 
 
 class InstrumentModule(InstrumentBase):
@@ -33,15 +36,14 @@ class InstrumentModule(InstrumentBase):
     Args:
         parent: The instrument to which this module should be
           attached.
-
         name: The name of this module.
+        **kwargs: Forwarded to the base class.
 
     """
 
-    def __init__(self,
-                 parent: InstrumentBase,
-                 name: str,
-                 **kwargs: Any) -> None:
+    def __init__(
+        self, parent: InstrumentBase, name: str, **kwargs: Unpack[InstrumentBaseKWArgs]
+    ) -> None:
         # need to specify parent before `super().__init__` so that the right
         # `full_name` is available in that scope. `full_name` is used for
         # registering the filter for the log messages. It is composed by

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/instrument/instrument.py

@@ -9,15 +9,14 @@ from typing import TYPE_CHECKING, Any, Protocol, TypeVar, overload
 from qcodes.utils import strip_attrs
 from qcodes.validators import Anything
 
-from .instrument_base import InstrumentBase
+from .instrument_base import InstrumentBase, InstrumentBaseKWArgs
 from .instrument_meta import InstrumentMeta
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from typing_extensions import Unpack
 
     from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
 
-
 log = logging.getLogger(__name__)
 
 
@@ -35,9 +34,19 @@ class InstrumentProtocol(Protocol):
 
 T = TypeVar("T", bound="Instrument")
 
+# a metaclass that overrides __call__ means that we lose
+# both the args and return type hints.
+# Since our metaclass does not modify the signature
+# is is safe simply not to use that metaclass in typechecking context.
+# See https://github.com/microsoft/pyright/discussions/5561 and
+# https://github.com/microsoft/pyright/issues/5488
+if TYPE_CHECKING:
+    instrument_meta_class = type
+else:
+    instrument_meta_class = InstrumentMeta
 
-class Instrument(InstrumentBase, metaclass=InstrumentMeta):
 
+class Instrument(InstrumentBase, metaclass=instrument_meta_class):
     """
     Base class for all QCodes instruments.
 
@@ -56,16 +65,11 @@ class Instrument(InstrumentBase, metaclass=InstrumentMeta):
     _type: type[Instrument] | None = None
     _instances: weakref.WeakSet[Instrument] = weakref.WeakSet()
 
-    def __init__(
-        self,
-        name: str,
-        metadata: Mapping[Any, Any] | None = None,
-        label: str | None = None,
-    ) -> None:
+    def __init__(self, name: str, **kwargs: Unpack[InstrumentBaseKWArgs]) -> None:
 
         self._t0 = time.time()
 
-        super().__init__(name=name, metadata=metadata, label=label)
+        super().__init__(name=name, **kwargs)
 
         self.add_parameter("IDN", get_cmd=self.get_idn, vals=Anything())
 

{qcodes-0.45.0 → qcodes-0.46.0}/src/qcodes/instrument/instrument_base.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 import collections.abc
 import logging
 import warnings
-from typing import TYPE_CHECKING, Any, ClassVar
+from collections.abc import Callable, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import numpy as np
+from typing_extensions import TypedDict, TypeVar, deprecated
 
 from qcodes.logger import get_instrument_logger
 from qcodes.metadatable import Metadatable, MetadatableWithName
@@ -16,6 +18,8 @@ from qcodes.utils import DelegateAttributes, full_class
 if TYPE_CHECKING:
     from collections.abc import Callable, Mapping, Sequence
 
+    from typing_extensions import NotRequired
+
     from qcodes.instrument.channel import ChannelTuple, InstrumentModule
     from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
 
@@ -23,6 +27,26 @@ from qcodes.utils import QCoDeSDeprecationWarning
 
 log = logging.getLogger(__name__)
 
+TParameter = TypeVar("TParameter", bound=ParameterBase, default=Parameter)
+
+
+class InstrumentBaseKWArgs(TypedDict):
+    """
+    This TypedDict defines the type of the kwargs that can be passed to the InstrumentBase class.
+    A subclass of VisaInstrument should take ``**kwargs: Unpack[InstrumentBaseKWArgs]`` as input
+    and forward this to the super class to ensure that it can accept all the arguments defined here.
+    """
+
+    metadata: NotRequired[Mapping[Any, Any] | None]
+    """
+    Additional static metadata to add to this
+    instrument's JSON snapshot.
+    """
+    label: NotRequired[str | None]
+    """
+    Nicely formatted name of the instrument; if None,
+    the ``name`` is used.
+    """
 
 class InstrumentBase(MetadatableWithName, DelegateAttributes):
     """
@@ -100,9 +124,9 @@ class InstrumentBase(MetadatableWithName, DelegateAttributes):
     def add_parameter(
         self,
         name: str,
-        parameter_class: type[ParameterBase] | None = None,
+        parameter_class: type[TParameter] | None = None,
         **kwargs: Any,
-    ) -> None:
+    ) -> TParameter:
         """
         Bind one Parameter to this instrument.
 
@@ -132,7 +156,7 @@ class InstrumentBase(MetadatableWithName, DelegateAttributes):
                 one.
         """
         if parameter_class is None:
-            parameter_class = Parameter
+            parameter_class = cast(type[TParameter], Parameter)
 
         if "bind_to_instrument" not in kwargs.keys():
             kwargs["bind_to_instrument"] = True
@@ -160,6 +184,30 @@ class InstrumentBase(MetadatableWithName, DelegateAttributes):
                 QCoDeSDeprecationWarning,
             )
             self.parameters[name] = param
+        return param
+
+    def remove_parameter(self, 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.
+
+        Args:
+            name: The name of the parameter to remove.
+
+        Raises:
+            KeyError: If the parameter does not exist on the instrument.
+        """
+        self.parameters.pop(name)
+
+        is_property = isinstance(getattr(self.__class__, name, None), property)
+
+        if not is_property and hasattr(self, name):
+            delattr(self, name)
 
     def add_function(self, name: str, **kwargs: Any) -> None:
         """
@@ -534,6 +582,10 @@ class InstrumentBase(MetadatableWithName, DelegateAttributes):
         return self.full_name
 
     @property
+    @deprecated(
+        "The private attribute `_name` is deprecated and will be removed. Use `full_name` instead.",
+        category=QCoDeSDeprecationWarning,
+    )
     def _name(self) -> str:
         """
         Private alias kept here for backwards compatibility