Update to remove use of deprecated constructs

src/qcodes_contrib_drivers/drivers/BlueFors/BlueFors.py

@@ -170,10 +170,10 @@
             df.sort_index(inplace=True)
             return df.iloc[-1]["y"]
         except (PermissionError, OSError) as err:
-            self.log.warn('Cannot access log file: {}. Returning np.nan instead of the temperature value.'.format(err))
+            self.log.warning('Cannot access log file: {}. Returning np.nan instead of the temperature value.'.format(err))
             return np.nan
         except IndexError as err:
-            self.log.warn('Cannot parse log file: {}. Returning np.nan instead of the temperature value.'.format(err))
+            self.log.warning('Cannot parse log file: {}. Returning np.nan instead of the temperature value.'.format(err))
             return np.nan
 
 
@@ -211,8 +211,8 @@
 
             return df.iloc[-1]['ch'+str(channel)+'_pressure']
         except (PermissionError, OSError) as err:
-            self.log.warn('Cannot access log file: {}. Returning np.nan instead of the pressure value.'.format(err))
+            self.log.warning('Cannot access log file: {}. Returning np.nan instead of the pressure value.'.format(err))
             return np.nan
         except IndexError as err:
-            self.log.warn('Cannot parse log file: {}. Returning np.nan instead of the pressure value.'.format(err))
+            self.log.warning('Cannot parse log file: {}. Returning np.nan instead of the pressure value.'.format(err))
             return np.nan

src/qcodes_contrib_drivers/drivers/ERAInstruments/erasynth.py

@@ -20,7 +20,9 @@
 import json
 import logging
 
-from qcodes import VisaInstrument, Parameter, validators
+from qcodes import validators
+from qcodes.instrument import VisaInstrument
+from qcodes.parameters import Parameter
 
 try:
     import pyvisa
@@ -674,7 +676,7 @@
         num_tests = len(par_values)
         for i, (name, val) in enumerate(par_values):
             print(f"\r[{i+1:2d}/{num_tests}] Running...", end="")
-            self.set(name, val)
+            self.parameters[name].set(val)
 
         print("\nDone!")
 

src/qcodes_contrib_drivers/drivers/OxfordInstruments/ILM200.py

@@ -10,8 +10,9 @@
 
 from time import sleep
 import pyvisa
+import pyvisa.constants
 import logging
-from qcodes import VisaInstrument
+from qcodes.instrument import VisaInstrument
 
 
 class OxfordInstruments_ILM200(VisaInstrument):
@@ -132,7 +133,7 @@
             if len(idparts) < 4:
                 idparts += [None] * (4 - len(idparts))
         except Exception as ex:
-            logging.warn('Error getting or interpreting *IDN?: ' + repr(idstr))
+            logging.warning('Error getting or interpreting *IDN?: ' + repr(idstr))
             logging.debug(ex)
             idparts = [None, None, None, None]
 

src/qcodes_contrib_drivers/drivers/QuTech/IVVI.py

@@ -2,12 +2,14 @@
 import logging
 import numpy as np
 import pyvisa  # used for the parity constant
+import pyvisa.constants
 import traceback
 import threading
 import math
 
-from qcodes import VisaInstrument, validators as vals
-from qcodes.utils.validators import Bool, Numbers
+from qcodes import validators as vals
+from qcodes.validators import Bool, Numbers
+from qcodes.instrument import VisaInstrument
 
 
 class IVVI(VisaInstrument):
@@ -26,7 +28,7 @@
     http://qtwork.tudelft.nl/~schouten/ivvi/doc-d5/rs232linkformat.txt
     A copy of this file can be found at the bottom of this file.
     '''
-    
+
     full_range = 4000.0
     half_range = full_range / 2
     resolution = 16
@@ -193,7 +195,7 @@
 
     def set_dacs_zero(self):
         for i in range(self._numdacs):
-            self.set('dac{}'.format(i + 1), 0)
+            self.parameters['dac{}'.format(i + 1)](0)
 
     def linspace(self, start: float, end: float, samples: int, flexible: bool = False, bip: bool = True):
         """
@@ -222,7 +224,7 @@
 
                 linspace(-100,100,8) -> [-99.88555733577478, .. 6 more ..
                                         , 99.64141298542764]
-            
+
                 linspace(-1000, 1000, 2000) ->
                     [-976.4858472571908, .. 1998 more .., 975.6923781185626 ]
 
@@ -241,12 +243,12 @@
 
                 This prevents oversampling. Use flexable = True to adapt the number
                 of points.
-                                     
+
             Resolution limited sweep using the flexable option::
 
                 linspace(500, 502, 100, True) -> [500.0991836423285, .. 14 more ..
                                                  , 501.9302662699321]
-            
+
             A too narrow range::
 
                 linspace(0, 0.01, 100, True) # -> ValueError: No DAC values exist
@@ -357,7 +359,7 @@
         proceed = True
 
         if self.check_setpoints():
-            cur_val = self.get('dac{}'.format(channel))
+            cur_val = self.parameters['dac{}'.format(channel)]()
             # dac range in mV / 16 bits FIXME make range depend on polarity
             byte_res = self.full_range / 2**16
             # eps is a magic number to correct for an offset in the values

src/qcodes_contrib_drivers/drivers/Spectrum/M4i.py

@@ -622,15 +622,15 @@
     # checks if requirements for the compensation get and set functions are met
     def _get_compensation(self, i):
         # if HF enabled
-        if self.get(f'input_path_{i}') == 1:
+        if self.parameters[f'input_path_{i}']() == 1:
             return self._param32bit(getattr(pyspcm, f'SPC_ACDC_OFFS_COMPENSATION{i}'))
         else:
             logging.info("M4i: HF path not set, ACDC offset compensation parameter will be ignored by the M4i card\n")
             return M4i._NO_HF_MODE
 
     def _set_compensation(self, i, value):
         # if HF enabled
-        if self.get(f'input_path_{i}') == 1:
+        if self.parameters[f'input_path_{i}']() == 1:
             self._set_param32bit(
                 getattr(pyspcm, f'SPC_ACDC_OFFS_COMPENSATION{i}'), value)
         else:
@@ -723,7 +723,7 @@
         if memsize is None:
             memsize = self._channel_memsize
         posttrigger_size = memsize - self._channel_pretrigger_memsize
-        mV_range = self.get(f'range_channel_{channel}')
+        mV_range = self.parameter[f'range_channel_{channel}']()
         cx = self._channel_mask()
         self.enable_channels(cx)
         data = self.single_software_trigger_acquisition(
@@ -753,17 +753,17 @@
             lp_filter (Optional[int]): enable (1) or disable (0) the 20 MHz low pass filter
         """
         # initialize
-        self.set(f'input_path_{channel_index}', input_path)
+        self.parameters[f'input_path_{channel_index}'](input_path)
         if termination is not None:
-            self.set(f'termination_{channel_index}', termination)
+            self.parameters[f'termination_{channel_index}'](termination)
         if coupling is not None:
-            self.set(f'ACDC_coupling_{channel_index}', coupling)
+            self.parameters[f'ACDC_coupling_{channel_index}'](coupling)
         if lp_filter is not None:
-            self.set(f'anti_aliasing_filter_{channel_index}', lp_filter)
-        self.set(f'range_channel_{channel_index}', mV_range)  # note: set after voltage range
+            self.parameters[f'anti_aliasing_filter_{channel_index}'](lp_filter)
+        self.parameters[f'range_channel_{channel_index}'](mV_range)  # note: set after voltage range
         # can only be used with DC coupling and 50 Ohm path (hf)
         if compensation is not None:
-            self.set(f'ACDC_offs_compensation_{channel_index}', compensation)
+            self.parameters[f'ACDC_offs_compensation_{channel_index}'](compensation)
 
     def set_ext0_OR_trigger_settings(self, trig_mode, termination, coupling, level0, level1=None):
         """ Configures ext0 trigger
@@ -793,10 +793,10 @@
         acquisition."""
         self.trigger_or_mask(0)
         self.channel_or_mask(getattr(pyspcm, f'SPC_TMASK0_CH{i}'))
-        self.set(f'trigger_channel_{i}_level_0', bitlevel0)
+        self.parameters[f'trigger_channel_{i}_level_0'](bitlevel0)
         if(bitlevel1 != None):
-            self.set(f'trigger_channel_{i}_level_1', bitlevel1)
-        self.set(f'trigger_mode_channel_{i}', trig_mode)  # trigger mode
+            self.parameters[f'trigger_channel_{i}_level_1'](bitlevel1)
+        self.parameters[f'trigger_mode_channel_{i}'](trig_mode)  # trigger mode
 
     def setup_multi_recording(self, posttrigger_size, n_triggers=1,
                               pretrigger_size=None, boxcar_average=False):
@@ -876,7 +876,7 @@
         resolution = self.ADC_to_voltage.cache()
         voltages = np.zeros((numch, len(raw_data)//numch))
         for i,ch in enumerate(active_channels):
-            mV_range = self.get(f'range_channel_{ch}')
+            mV_range = self.parameters[f'range_channel_{ch}']()
             voltages[i,:] = raw_data[i::numch] * (mV_range / 1000 / resolution / box_averages)
         return voltages
 

src/qcodes_contrib_drivers/drivers/StanfordResearchSystems/SIM928.py

@@ -220,8 +220,8 @@
             maxsteps = 0
             deltav = {}
             for i in vdict:
-                deltav[i] = vdict[i]-self.get('volt_{}'.format(i))
-                stepsize = self.get('volt_{}_step'.format(i))
+                deltav[i] = vdict[i]-self.parameters['volt_{}'.format(i)]()
+                stepsize = self.parameters['volt_{}_step'.format(i)]()
                 steps = abs(int(np.ceil(deltav[i]/stepsize)))
                 if steps > maxsteps:
                     maxsteps = steps
@@ -234,13 +234,13 @@
             done = []
             prevvals = {}
             for i in vdict:
-                prevvals[i] = self.get('volt_{}'.format(i))
+                prevvals[i] = self.parameters['volt_{}'.format(i)]()
             while len(done) != len(vdict):
                 intermediate.append({})
                 for i in vdict:
                     if i in done:
                         continue
-                    stepsize = self.get('volt_{}_step'.format(i))
+                    stepsize = self.parameters['volt_{}_step'.format(i)]()
                     deltav = vdict[i]-prevvals[i]
                     if abs(deltav) <= stepsize:
                         intermediate[-1][i] = vdict[i]

src/qcodes_contrib_drivers/drivers/ZurichInstruments/ZIHDAWG8.py

@@ -10,8 +10,8 @@
 import numpy as np
 import zhinst.utils
 
-from qcodes import Instrument
-from qcodes.utils import validators as validators
+from qcodes.instrument import Instrument
+from qcodes import validators
 
 WARNING_CLIPPING = r"^Warning \(line: [0-9]+\): [a-zA-Z0-9_]+ has a higher " \
                    r"amplitude than 1.0, waveform amplitude will be limited " \
@@ -88,7 +88,7 @@
         Args:
             channel_number: Output channel that should be enabled.
         """
-        self.set('sigouts_{}_on'.format(channel_number), 1)
+        self.parameters['sigouts_{}_on'.format(channel_number)](1)
 
     def disable_channel(self, channel_number: int) -> None:
         """
@@ -97,7 +97,7 @@
         Args:
             channel_number: Output channel that should be disabled.
         """
-        self.set('sigouts_{}_on'.format(channel_number), 0)
+        self.parameters['sigouts_{}_on'.format(channel_number)](0)
 
     def start_awg(self, awg_number: int):
         """
@@ -106,7 +106,7 @@
         Args:
             awg_number: The AWG that should be enabled.
         """
-        self.set('awgs_{}_enable'.format(awg_number), 1)
+        self.parameters['awgs_{}_enable'.format(awg_number)](1)
 
     def stop_awg(self, awg_number: int) -> None:
         """
@@ -115,7 +115,7 @@
         Args:
             awg_number: The AWG that should be disabled.
         """
-        self.set('awgs_{}_enable'.format(awg_number), 0)
+        self.parameters['awgs_{}_enable'.format(awg_number)](0)
 
     def waveform_to_wave(self, wave_name: str, waveform: np.ndarray) -> None:
         """
@@ -283,9 +283,9 @@
                 position of the waveform in the Waveforms sub-tab of the AWG tab
                 in the GUI.
         """
-        self.set('awgs_{}_waveform_index'.format(awg_number), index)
+        self.parameters['awgs_{}_waveform_index'.format(awg_number)](index)
         self.daq.sync()
-        self.set('awgs_{}_waveform_data'.format(awg_number), waveform)
+        self.parameters['awgs_{}_waveform_data'.format(awg_number)](waveform)
 
     def set_channel_grouping(self, group: int) -> None:
         """
@@ -295,7 +295,7 @@
             group: 0: groups of 2. 1: groups of 4. 2: groups of 8 i.e., one
                 sequencer program controls 8 outputs.
         """
-        self.set('system_awg_channelgrouping', group)
+        self.system_awg_channelgrouping(group)
 
     def create_parameters_from_node_tree(self, parameters: dict) -> None:
         """