Use typed parameter kwargs in drivers

src/qcodes/instrument_drivers/CopperMountain/_M5xxx.py

@@ -7,6 +7,7 @@
 from qcodes.parameters import (
     ManualParameter,
     MultiParameter,
+    MultiParameterKWArgs,
     Parameter,
     ParamRawDataType,
     create_on_off_val_mapping,
@@ -637,9 +638,9 @@ def __init__(
         start: float,
         stop: float,
         number_of_points: int,
-        instrument: CopperMountainM5xxx,
+        *,
         expected_measurement_duration: float = 600,
-        **kwargs: Any,
+        **kwargs: "Unpack[MultiParameterKWArgs[tuple[NDArray, NDArray], CopperMountainM5xxx]]",
     ) -> None:
         """
         Linear frequency sweep that returns magnitude and phase for a single
@@ -650,40 +651,57 @@ def __init__(
             start: Start frequency of linear sweep
             stop: Stop frequency of linear sweep
             number_of_points: Number of points of linear sweep
-            instrument: Instrument to which sweep is bound to.
             expected_measurement_duration: Adjusts instrument timeout (seconds). Defaults to 600 seconds.
-            **kwargs: Any
+            **kwargs: Keyword arguments forwarded to MultiParameter.
 
         """
 
         self.expected_measurement_duration = expected_measurement_duration
 
-        super().__init__(
-            name,
-            instrument=instrument,
-            names=(
+        instrument = kwargs.get("instrument")
+        assert instrument is not None
+
+        kw: dict[str, Any] = dict(kwargs)
+        kw.setdefault(
+            "names",
+            (
                 f"{instrument.short_name}_{name}_magnitude",
                 f"{instrument.short_name}_{name}_phase",
             ),
-            labels=(
+        )
+        kw.setdefault(
+            "labels",
+            (
                 f"{instrument.short_name} {name} magnitude",
                 f"{instrument.short_name} {name} phase",
             ),
-            units=("dB", "rad"),
-            setpoint_units=(("Hz",), ("Hz",)),
-            setpoint_labels=(
+        )
+        kw.setdefault("units", ("dB", "rad"))
+        kw.setdefault("setpoint_units", (("Hz",), ("Hz",)))
+        kw.setdefault(
+            "setpoint_labels",
+            (
                 (f"{instrument.short_name} frequency",),
                 (f"{instrument.short_name} frequency",),
             ),
-            setpoint_names=(
+        )
+        kw.setdefault(
+            "setpoint_names",
+            (
                 (f"{instrument.short_name}_frequency",),
                 (f"{instrument.short_name}_frequency",),
             ),
-            shapes=(
+        )
+        kw.setdefault(
+            "shapes",
+            (
                 (number_of_points,),
                 (number_of_points,),
             ),
-            **kwargs,
+        )
+        super().__init__(
+            name,
+            **kw,
         )
         self.set_sweep(start, stop, number_of_points)
 
@@ -746,44 +764,46 @@ class PointMagPhase(
     def __init__(
         self,
         name: str,
-        instrument: CopperMountainM5xxx,
+        *,
         expected_measurement_duration: float = 600,
-        **kwargs: Any,
+        **kwargs: "Unpack[MultiParameterKWArgs[tuple[np.floating, np.floating], CopperMountainM5xxx]]",
     ) -> None:
         """Magnitude and phase measurement of a single point at start
         frequency.
 
         Args:
             name: Name of point measurement
-            instrument:  Instrument to which parameter is bound to.
             expected_measurement_duration: Adjusts instrument timeout (seconds). Defaults to 600 seconds.
-            **kwargs: Any
+            **kwargs: Keyword arguments forwarded to MultiParameter.
 
         """
 
         self.expected_measurement_duration = expected_measurement_duration
 
-        super().__init__(
-            name,
-            instrument=instrument,
-            names=(
+        instrument = kwargs.get("instrument")
+        assert instrument is not None
+
+        kw: dict[str, Any] = dict(kwargs)
+        kw.setdefault(
+            "names",
+            (
                 f"{instrument.short_name}_{name}_magnitude",
                 f"{instrument.short_name}_{name}_phase",
             ),
-            labels=(
+        )
+        kw.setdefault(
+            "labels",
+            (
                 f"{instrument.short_name} {name} magnitude",
                 f"{instrument.short_name} {name} phase",
             ),
-            units=("dB", "rad"),
-            setpoints=(
-                (),
-                (),
-            ),
-            shapes=(
-                (),
-                (),
-            ),
-            **kwargs,
+        )
+        kw.setdefault("units", ("dB", "rad"))
+        kw.setdefault("setpoints", ((), ()))
+        kw.setdefault("shapes", ((), ()))
+        super().__init__(
+            name,
+            **kw,
         )
 
     def get_raw(self) -> tuple[ParamRawDataType, ParamRawDataType]:
@@ -844,44 +864,46 @@ class PointIQ(MultiParameter[tuple[np.floating, np.floating], CopperMountainM5xx
     def __init__(
         self,
         name: str,
-        instrument: CopperMountainM5xxx,
+        *,
         expected_measurement_duration: float = 600,
-        **kwargs: Any,
+        **kwargs: "Unpack[MultiParameterKWArgs[tuple[np.floating, np.floating], CopperMountainM5xxx]]",
     ) -> None:
         """I and Q measurement of a single point at start
         frequency.
 
         Args:
             name: Name of point measurement
-            instrument:  Instrument to which parameter is bound to.
             expected_measurement_duration: Adjusts instrument timeout (seconds). Defaults to 600 seconds.
-            **kwargs: Any
+            **kwargs: Keyword arguments forwarded to MultiParameter.
 
         """
 
         self.expected_measurement_duration = expected_measurement_duration
 
-        super().__init__(
-            name,
-            instrument=instrument,
-            names=(
+        instrument = kwargs.get("instrument")
+        assert instrument is not None
+
+        kw: dict[str, Any] = dict(kwargs)
+        kw.setdefault(
+            "names",
+            (
                 f"{instrument.short_name}_{name}_i",
                 f"{instrument.short_name}_{name}_q",
             ),
-            labels=(
+        )
+        kw.setdefault(
+            "labels",
+            (
                 f"{instrument.short_name} {name} i",
                 f"{instrument.short_name} {name} q",
             ),
-            units=("V", "V"),
-            setpoints=(
-                (),
-                (),
-            ),
-            shapes=(
-                (),
-                (),
-            ),
-            **kwargs,
+        )
+        kw.setdefault("units", ("V", "V"))
+        kw.setdefault("setpoints", ((), ()))
+        kw.setdefault("shapes", ((), ()))
+        super().__init__(
+            name,
+            **kw,
         )
 
     def get_raw(self) -> tuple[ParamRawDataType, ParamRawDataType]:

src/qcodes/instrument_drivers/Keithley/Keithley_7510.py

@@ -13,6 +13,8 @@
     DelegateParameter,
     MultiParameter,
     Parameter,
+    ParameterBaseKWArgs,
+    ParameterKWArgs,
     ParamRawDataType,
     create_on_off_val_mapping,
     invert_val_mapping,
@@ -38,13 +40,19 @@ def __init__(
         names: "Sequence[str]",
         shapes: "Sequence[Sequence[int]]",
         setpoints: "Sequence[Sequence[Any]] | None",
-        **kwargs: Any,
+        units: "Sequence[str] | None" = None,
+        setpoint_units: "Sequence[Sequence[str]] | None" = None,
+        setpoint_names: "Sequence[Sequence[str]] | None" = None,
+        **kwargs: "Unpack[ParameterBaseKWArgs]",
     ):
         super().__init__(
             name="data_array_7510",
             names=names,
             shapes=shapes,
             setpoints=setpoints,
+            units=units,
+            setpoint_units=setpoint_units,
+            setpoint_names=setpoint_names,
             **kwargs,
         )
         for param_name in self.names:
@@ -65,10 +73,11 @@ def __init__(
         start: Parameter,
         stop: Parameter,
         n_points: Parameter,
-        *args: Any,
-        **kwargs: Any,
+        *,
+        name: str,
+        **kwargs: "Unpack[ParameterKWArgs]",
     ):
-        super().__init__(*args, **kwargs)
+        super().__init__(name, **kwargs)
         self._start = start
         self._stop = stop
         self._n_points = n_points

src/qcodes/instrument_drivers/Keithley/Keithley_s46.py

@@ -4,13 +4,13 @@
 
 import re
 from itertools import product
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, ClassVar
 
 from qcodes.instrument import (
     VisaInstrument,
     VisaInstrumentKWArgs,
 )
-from qcodes.parameters import Parameter, ParamRawDataType
+from qcodes.parameters import Parameter, ParameterKWArgs, ParamRawDataType
 
 if TYPE_CHECKING:
     from typing_extensions import Unpack
@@ -72,12 +72,12 @@ class S46Parameter(Parameter[ParamRawDataType, "KeithleyS46"]):
     def __init__(
         self,
         name: str,
-        instrument: "KeithleyS46",
+        *,
         channel_number: int,
         lock: KeithleyS46RelayLock,
-        **kwargs: Any,
+        **kwargs: "Unpack[ParameterKWArgs[ParamRawDataType, KeithleyS46]]",
     ):
-        super().__init__(name, instrument=instrument, **kwargs)
+        super().__init__(name, **kwargs)
 
         self._lock = lock
         self._channel_number = channel_number

src/qcodes/instrument_drivers/Keithley/_Keithley_2600.py

@@ -20,6 +20,7 @@
 from qcodes.parameters import (
     Parameter,
     ParameterBase,
+    ParameterKWArgs,
     ParameterWithSetpoints,
     ParamRawDataType,
     create_on_off_val_mapping,
@@ -544,8 +545,8 @@ class Keithley2600MeasurementStatus(StrEnum):
 
 
 class _ParameterWithStatus(Parameter):
-    def __init__(self, *args: Any, **kwargs: Any):
-        super().__init__(*args, **kwargs)
+    def __init__(self, name: str, **kwargs: Unpack[ParameterKWArgs]):
+        super().__init__(name, **kwargs)
 
         self._measurement_status: Keithley2600MeasurementStatus | None = None
 

src/qcodes/instrument_drivers/Keysight/Infiniium.py

@@ -25,7 +25,9 @@
 from qcodes.parameters import (
     Parameter,
     ParameterBase,
+    ParameterKWArgs,
     ParameterWithSetpoints,
+    ParameterWithSetpointsKWArgs,
     create_on_off_val_mapping,
 )
 from qcodes.utils.deprecate import QCoDeSDeprecationWarning
@@ -41,12 +43,20 @@ class DSOTimeAxisParam(Parameter):
     Time axis parameter for the Infiniium series DSO.
     """
 
-    def __init__(self, xorigin: float, xincrement: float, points: int, **kwargs: Any):
+    def __init__(
+        self,
+        xorigin: float,
+        xincrement: float,
+        points: int,
+        *,
+        name: str,
+        **kwargs: "Unpack[ParameterKWArgs]",
+    ):
         """
         Initialize time axis. If values are unknown, they can be initialized to zero and
         filled in later.
         """
-        super().__init__(**kwargs)
+        super().__init__(name, **kwargs)
 
         self.xorigin = xorigin
         self.xincrement = xincrement
@@ -69,12 +79,20 @@ class DSOFrequencyAxisParam(Parameter):
     Frequency axis parameter for the Infiniium series DSO.
     """
 
-    def __init__(self, xorigin: float, xincrement: float, points: int, **kwargs: Any):
+    def __init__(
+        self,
+        xorigin: float,
+        xincrement: float,
+        points: int,
+        *,
+        name: str,
+        **kwargs: "Unpack[ParameterKWArgs]",
+    ):
         """
         Initialize frequency axis. If values are unknown, they can be initialized
         to zero and filled in later.
         """
-        super().__init__(**kwargs)
+        super().__init__(name, **kwargs)
 
         self.xorigin = xorigin
         self.xincrement = xincrement
@@ -113,15 +131,15 @@ class DSOTraceParam(
     def __init__(
         self,
         name: str,
-        instrument: "KeysightInfiniiumChannel | KeysightInfiniiumFunction",
+        *,
         channel: str,
-        **kwargs: Any,
+        **kwargs: "Unpack[ParameterWithSetpointsKWArgs[npt.NDArray, KeysightInfiniiumChannel | KeysightInfiniiumFunction]]",
     ):
         """
         Initialize DSOTraceParam bound to a specific channel.
         """
         self._ch_valid = False
-        super().__init__(name, instrument=instrument, **kwargs)
+        super().__init__(name, **kwargs)
         self._channel = channel
         # This parameter will be updated prior to being retrieved if
         # self.root_instrument.auto_digitize is true.