black formatter

1 files changed, 247 insertions, 199 deletions

diff --git a/examples/lock_eit.py b/examples/lock_eit.py
index f226935..40612e6 100644
--- a/examples/lock_eit.py
+++ b/examples/lock_eit.py
@@ -15,62 +15,66 @@ from qolab.data import TraceSetSameX, TraceXY, Trace
 from qolab.hardware.i_server import I800
 
 # this should be done before justpy is called or log formatter does not work
-logging.basicConfig(format='%(asctime)s %(levelname)8s %(name)s: %(message)s', datefmt='%m/%d/%Y %H:%M:%S')
+logging.basicConfig(
+    format="%(asctime)s %(levelname)8s %(name)s: %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+)
 
 
-l = logging.getLogger('qolab.gui.web')
+l = logging.getLogger("qolab.gui.web")
 l.setLevel(logging.INFO)
-l = logging.getLogger('qolab.tsdb')
+l = logging.getLogger("qolab.tsdb")
 l.setLevel(logging.INFO)
-logger = logging.getLogger('Magnetometer')
+logger = logging.getLogger("Magnetometer")
 logger.setLevel(logging.INFO)
 
+
 def getConfig(apparatus):
     config = apparatus.config.copy()
     ai = apparatus.instruments
     for n, i in ai.items():
-        config[n]=i.getConfig()
+        config[n] = i.getConfig()
     return config
 
+
 def initLog(extra_tags={}):
     errorTrace = Trace("error")
-    errorTrace.config['unit']='V'
+    errorTrace.config["unit"] = "V"
     timeTrace = Trace("time")
-    timeTrace.config['unit']='S'
-    timeTrace.config['type'] = 'timestamp'
+    timeTrace.config["unit"] = "S"
+    timeTrace.config["type"] = "timestamp"
     errorLog = TraceXY("error")
     errorLog.x = timeTrace
     errorLog.y = errorTrace
 
     freqTrace = Trace("frequency")
-    freqTrace.config['unit']='Hz'
+    freqTrace.config["unit"] = "Hz"
     freqLog = TraceXY("frequency")
     freqLog.x = timeTrace
     freqLog.y = freqTrace
 
     feedbackTrace = Trace("feedback")
-    feedbackTrace.config['unit']='Hz'
+    feedbackTrace.config["unit"] = "Hz"
     feedbackLog = TraceXY("feedback")
     feedbackLog.x = timeTrace
     feedbackLog.y = feedbackTrace
 
     eitTrace = Trace("eit")
-    eitTrace.config['unit']='V'
+    eitTrace.config["unit"] = "V"
     eitLog = TraceXY("eit")
     eitLog.x = timeTrace
     eitLog.y = eitTrace
 
     rfPoutTrace = Trace("rfPout")
-    rfPoutTrace.config['unit']='dBm'
+    rfPoutTrace.config["unit"] = "dBm"
     rfPoutLog = TraceXY("rfPout")
     rfPoutLog.x = timeTrace
     rfPoutLog.y = rfPoutTrace
 
-    
     cellTemperatureLog = TraceXY("cellTemperature")
     cellTemperatureLog.x = timeTrace
     cellTemperatureLog.y = Trace("cellTemperature")
-    cellTemperatureLog.y.config['unit'] = 'C'
+    cellTemperatureLog.y.config["unit"] = "C"
 
     log = TraceSetSameX("timelog")
     log.addTrace(errorLog)
@@ -79,24 +83,26 @@ def initLog(extra_tags={}):
     log.addTrace(eitLog)
     log.addTrace(rfPoutLog)
     log.addTrace(cellTemperatureLog)
-    log.config['tags']['apparatus']=getConfig(apparatus)
-    log.config['tags'].update(extra_tags)
+    log.config["tags"]["apparatus"] = getConfig(apparatus)
+    log.config["tags"].update(extra_tags)
     return log
 
+
 async def feedbackLoop(apparatus, nsteps):
     # while True:
-    for i in range(0,nsteps):
+    for i in range(0, nsteps):
         adjustRFandLog(apparatus)
         await asyncio.sleep(0.1)
     apparatus.runStatus = False
 
+
 def adjustRFandLog(apparatus):
     timenow = time.time()
 
     ai = apparatus.instruments
-    pid = ai['pid']
-    scope_fdbk = ai['scope.feedback']
-    log   = apparatus.gui_log.traces
+    pid = ai["pid"]
+    scope_fdbk = ai["scope.feedback"]
+    log = apparatus.gui_log.traces
 
     err, eit = apparatus.getErrAndEit()
     fdbck = pid.feedback(err)
@@ -106,9 +112,10 @@ def adjustRFandLog(apparatus):
 
     rfPout = apparatus.getRFAmplitude()
 
-    apparatus.getBCurrent(); # this automatically logs value to TSDB
+    apparatus.getBCurrent()
+    # this automatically logs value to TSDB
 
-    tCell = ai['cellTemperatureController'].getTemperature()
+    tCell = ai["cellTemperatureController"].getTemperature()
 
     log.addPointToTrace(timenow)
     log.addPointToTrace(err, "error")
@@ -118,194 +125,186 @@ def adjustRFandLog(apparatus):
     log.addPointToTrace(eit, "eit")
     log.addPointToTrace(tCell, "cellTemperature")
 
+
 async def initial_lock_to_eit(apparatus, extra_tags={}):
     rfPout = apparatus.getRFAmplitude()
-    apparatus.state = f'Initial lock RF power {rfPout} dBm'
+    apparatus.state = f"Initial lock RF power {rfPout} dBm"
     logger.info(apparatus.state)
     update_webpage(apparatus=apparatus)
 
     ai = apparatus.instruments
-    apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
-    ai['pid'].reset()
-    ai['pid'].setEnable(True)
+    apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
+    ai["pid"].reset()
+    ai["pid"].setEnable(True)
     apparatus.runStatus = True
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=50)
-            )
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=50))
+
 
 async def calibratingLockin(apparatus, extra_tags={}):
     ai = apparatus.instruments
     rfPout = apparatus.getRFAmplitude()
-    apparatus.state = f'Calibrating lockin response at RF power {rfPout} dBm'
+    apparatus.state = f"Calibrating lockin response at RF power {rfPout} dBm"
     logger.info(apparatus.state)
     update_webpage(apparatus=apparatus)
-    ai['pid'].setEnable(False)
-    ai['pid'].reset()
-    apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=20)
-            )
-
-    fr0 = ai['rfgen'].getFreqFixed()
+    ai["pid"].setEnable(False)
+    ai["pid"].reset()
+    apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
+
+    fr0 = ai["rfgen"].getFreqFixed()
     df = 10
-    ai['pid'].setEnable(False)
-    ai['pid'].reset()
-    apparatus.setRFreq(fr0+df)
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=20)
-            )
+    ai["pid"].setEnable(False)
+    ai["pid"].reset()
+    apparatus.setRFreq(fr0 + df)
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
     apparatus.setRFreq(fr0)
 
-    log   = apparatus.gui_log.traces
-    trE=log.getTrace('error')
+    log = apparatus.gui_log.traces
+    trE = log.getTrace("error")
 
     e1 = np.mean(trE.y.values[0:20])
     e2 = np.mean(trE.y.values[20:])
-    dE = e2-e1
-    slope = dE/df
+    dE = e2 - e1
+    slope = dE / df
     apparatus.setLockinSlope(slope)
 
-    logger.info(f'dE = {dE}')
-    logger.info(f'lockin error signal slope = {slope} V/Hz')
-    ai['error_signal_response_to_eit_detuning'].conversion_factor = float(slope)
+    logger.info(f"dE = {dE}")
+    logger.info(f"lockin error signal slope = {slope} V/Hz")
+    ai["error_signal_response_to_eit_detuning"].conversion_factor = float(slope)
 
     return float(slope)
 
+
 async def responseToChangeOfBfieldControlVoltage(apparatus, extra_tags={}):
     ai = apparatus.instruments
     rfPout = apparatus.getRFAmplitude()
-    apparatus.state = f'Calibrating lockin response to change of Bfield control voltage, {rfPout} dBm'
+    apparatus.state = (
+        f"Calibrating lockin response to change of Bfield control voltage, {rfPout} dBm"
+    )
     logger.info(apparatus.state)
     update_webpage(apparatus=apparatus)
-    ai['pid'].setEnable(True)
-    ai['pid'].reset()
-    apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+    ai["pid"].setEnable(True)
+    ai["pid"].reset()
+    apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
     dV = 0.01
-    ai['lockin'].AuxOut1=dV
+    ai["lockin"].AuxOut1 = dV
 
     # initial lock
-    ai['pid'].setEnable(True)
-    ai['pid'].reset()
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=20)
-            )
+    ai["pid"].setEnable(True)
+    ai["pid"].reset()
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
 
     # this is for the money lock
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=30)
-            )
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=30))
 
-    fr0 = ai['rfgen'].getFreqFixed()
+    fr0 = ai["rfgen"].getFreqFixed()
 
     # this is for the money lock
-    ai['lockin'].AuxOut1=0
-    ai['pid'].setEnable(True)
-    ai['pid'].reset()
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=30)
-            )
-    fr1 = ai['rfgen'].getFreqFixed()
+    ai["lockin"].AuxOut1 = 0
+    ai["pid"].setEnable(True)
+    ai["pid"].reset()
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=30))
+    fr1 = ai["rfgen"].getFreqFixed()
 
-    log   = apparatus.gui_log.traces
-    trE=log.getTrace('error')
+    log = apparatus.gui_log.traces
+    trE = log.getTrace("error")
 
     df = fr0 - fr1
-    slope = df/dV
+    slope = df / dV
 
-    logger.info(f'df = {df}')
-    logger.info(f'response to magnetic control voltage = {slope} Hz/V')
-    ai['B_control_voltage_to_eit_detuning'].conversion_factor = float(slope)
+    logger.info(f"df = {df}")
+    logger.info(f"response to magnetic control voltage = {slope} Hz/V")
+    ai["B_control_voltage_to_eit_detuning"].conversion_factor = float(slope)
 
     # relock to default state
-    ai['lockin'].AuxOut1=0
-    ai['pid'].setEnable(True)
-    ai['pid'].reset()
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=20)
-            )
+    ai["lockin"].AuxOut1 = 0
+    ai["pid"].setEnable(True)
+    ai["pid"].reset()
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
 
     return float(slope)
 
+
 async def record_magnetometer_noise(apparatus):
     ai = apparatus.instruments
     rfPout = apparatus.getRFAmplitude()
-    ai['pid'].setEnable(False)
+    ai["pid"].setEnable(False)
 
-    apparatus.state = f'Record magnetometer noise,  RF power {rfPout} dBm'
+    apparatus.state = f"Record magnetometer noise,  RF power {rfPout} dBm"
     logger.info(apparatus.state)
 
-    scope = ai['scope.monitor']
+    scope = ai["scope.monitor"]
     old_config = scope.getConfig()
-    tperdiv=1
+    tperdiv = 1
     scope.setTimePerDiv(tperdiv)
     scope.setRoll(True)
 
-    await asyncio.sleep(tperdiv*14 + 1)
-    errorTr=scope.getTrace(1, maxRequiredPoints=10000)
-    errorTr.config['label'] = 'error vs time'
-    errorTr.y.config['label'] = 'error'
+    await asyncio.sleep(tperdiv * 14 + 1)
+    errorTr = scope.getTrace(1, maxRequiredPoints=10000)
+    errorTr.config["label"] = "error vs time"
+    errorTr.y.config["label"] = "error"
     log = errorTr
-    log.config['tags']['apparatus']=getConfig(apparatus)
-    magNoise = BasicInstrument(device_nickname='.'.join(['magnetometer', 'noise']))
-    magNoise.config['FnamePrefix'] = 'magnetometer_noise'
-    magNoise.config['SavePath']=apparatus.config['SavePath']
+    log.config["tags"]["apparatus"] = getConfig(apparatus)
+    magNoise = BasicInstrument(device_nickname=".".join(["magnetometer", "noise"]))
+    magNoise.config["FnamePrefix"] = "magnetometer_noise"
+    magNoise.config["SavePath"] = apparatus.config["SavePath"]
     fname = magNoise.getNextDataFile()
     log.save(fname)
-    logger.info(f'Magnetometer noise file: {fname}')
+    logger.info(f"Magnetometer noise file: {fname}")
 
-    apparatus.gui_log.setTraces( log )
+    apparatus.gui_log.setTraces(log)
     update_webpage(apparatus=apparatus)
 
-    logger.info('Restoring scope settings')
+    logger.info("Restoring scope settings")
     scope.setConfig(old_config)
 
+
 async def longTermLock(apparatus, extra_tags={}):
     ai = apparatus.instruments
     rfPout = apparatus.getRFAmplitude()
-    apparatus.state = f'Long term lock RF power {rfPout} dBm'
+    apparatus.state = f"Long term lock RF power {rfPout} dBm"
     logger.info(apparatus.state)
 
     ai = apparatus.instruments
     rfPout = apparatus.getRFAmplitude()
     apparatus.runStatus = True
-    ai['pid'].setEnable(True)
+    ai["pid"].setEnable(True)
 
-    apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+    apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
     update_webpage(apparatus=apparatus)
 
-    res = await asyncio.gather(
-            feedbackLoop(apparatus, nsteps=10000000)
-            )
+    res = await asyncio.gather(feedbackLoop(apparatus, nsteps=10000000))
     return res
 
+
 async def sweepRFPower(apparatus, extra_tags={}, rfPowerList=[]):
-    apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+    apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
     ai = apparatus.instruments
     # for p in np.linspace(-10,10, 110):
-    ai['pid'].setEnable(True)
+    ai["pid"].setEnable(True)
     for p in rfPowerList:
-        ai['rfgen'].setRFAmplitude(p)
-        rfPout = ai['rfgen'].getRFAmplitude()
-        apparatus.state = f'lock with RF power {rfPout} dBm'
+        ai["rfgen"].setRFAmplitude(p)
+        rfPout = ai["rfgen"].getRFAmplitude()
+        apparatus.state = f"lock with RF power {rfPout} dBm"
         logger.info(apparatus.state)
         update_webpage(apparatus=apparatus)
-        ai['pid'].reset()
+        ai["pid"].reset()
         apparatus.runStatus = True
-        res = await asyncio.gather(
-                feedbackLoop(apparatus, nsteps=50)
-                )
+        res = await asyncio.gather(feedbackLoop(apparatus, nsteps=50))
     return res
 
 
 freqZero = 6_834_686_400
-#freqDeltaMp2 = 6_835_385_570; # T=83.7C
-freqDeltaMp2 = 6_835_393_258; # T=60C
+# freqDeltaMp2 = 6_835_385_570; # T=83.7C
+freqDeltaMp2 = 6_835_393_258
+# T=60C
 # freqDeltaMp2 = 6_835_396_000; # T=44.6C
 dfB = freqDeltaMp2 - freqZero
-freqDeltaMm2 = freqZero - dfB;
+freqDeltaMm2 = freqZero - dfB
+
 
 async def main():
-    app_nickname=apparatus.config['DeviceNickname']
+    app_nickname = apparatus.config["DeviceNickname"]
 
     task_wp_update_loop = asyncio.create_task(update_webpage_loop(update_interval=1))
 
@@ -314,14 +313,30 @@ async def main():
 
     logger.info("Accessing hardware")
     rm = pyvisa.ResourceManager()
-    instr_scope=rm.open_resource('TCPIP::192.168.0.61::INSTR')
-    scope_fdbk = SDS1104X(instr_scope, device_nickname='.'.join([app_nickname, 'scope.feedback']), tsdb_ingester=tsdb_ingester)
-    instr_scope=rm.open_resource('TCPIP::192.168.0.62::INSTR')
-    scope_mon = SDS1104X(instr_scope, device_nickname='.'.join([app_nickname, 'scope.monitor']), tsdb_ingester=tsdb_ingester)
-    instr_rfgen=rm.open_resource('TCPIP::192.168.0.114::INSTR')
-    rfgen = AgilentE8257D(instr_rfgen, device_nickname='.'.join([app_nickname, 'rfgen']), tsdb_ingester=tsdb_ingester)
-    instr_lockin=rm.open_resource('TCPIP::192.168.0.51::INSTR')
-    lockin = SRS_SR865A(instr_lockin, device_nickname='.'.join([app_nickname, 'lockin']), tsdb_ingester=tsdb_ingester)
+    instr_scope = rm.open_resource("TCPIP::192.168.0.61::INSTR")
+    scope_fdbk = SDS1104X(
+        instr_scope,
+        device_nickname=".".join([app_nickname, "scope.feedback"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+    instr_scope = rm.open_resource("TCPIP::192.168.0.62::INSTR")
+    scope_mon = SDS1104X(
+        instr_scope,
+        device_nickname=".".join([app_nickname, "scope.monitor"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+    instr_rfgen = rm.open_resource("TCPIP::192.168.0.114::INSTR")
+    rfgen = AgilentE8257D(
+        instr_rfgen,
+        device_nickname=".".join([app_nickname, "rfgen"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+    instr_lockin = rm.open_resource("TCPIP::192.168.0.51::INSTR")
+    lockin = SRS_SR865A(
+        instr_lockin,
+        device_nickname=".".join([app_nickname, "lockin"]),
+        tsdb_ingester=tsdb_ingester,
+    )
     # print('------ Header start -------------')
     # print(str.join('\n', scope.getHeader()))
     # print(str.join('\n', rfgen.getHeader()))
@@ -330,21 +345,31 @@ async def main():
     # traces = scope.getAllTraces()
     # pid = PID(100,400,0, sign=-1); # good for dm=-2 resonance
     # pid = PID(50,200,0, sign=-1, device_nickname='.'.join([app_nickname, 'pid']), tsdb_ingester=tsdb_ingester)
-    pid = PID(5,20,0, sign=-1, device_nickname='.'.join([app_nickname, 'pid']), tsdb_ingester=tsdb_ingester)
-
-    apparatus.instruments={}
+    pid = PID(
+        5,
+        20,
+        0,
+        sign=-1,
+        device_nickname=".".join([app_nickname, "pid"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+
+    apparatus.instruments = {}
     ai = apparatus.instruments
-    ai['rfgen'] = rfgen
-    ai['lockin']   = lockin
-    ai['pid']   = pid
-    ai['cellTemperatureController'] = I800(device_nickname='.'.join([app_nickname, 'cellTemperatureController']), tsdb_ingester=tsdb_ingester)
-    ai['scope.feedback'] = scope_fdbk
+    ai["rfgen"] = rfgen
+    ai["lockin"] = lockin
+    ai["pid"] = pid
+    ai["cellTemperatureController"] = I800(
+        device_nickname=".".join([app_nickname, "cellTemperatureController"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+    ai["scope.feedback"] = scope_fdbk
     scope_fdbk.setRoll(False)
     scope_fdbk.setRun(True)
     scope_fdbk.setTimePerDiv(0.0005)
     scope_fdbk.setChanVoltsPerDiv(1, 0.2)
     scope_fdbk.setChanVoltsPerDiv(3, 0.02)
-    ai['scope.monitor'] = scope_mon
+    ai["scope.monitor"] = scope_mon
     scope_mon.setRoll(False)
     scope_mon.setRun(True)
     scope_mon.setTimePerDiv(0.0005)
@@ -354,44 +379,59 @@ async def main():
     apparatus.state = None
     apparatus.runStatus = False
 
-    error_signal_response_to_eit_detuning = BasicInstrument(device_nickname='.'.join([app_nickname, 'error_signal_response_to_eit_detuning']), tsdb_ingester=tsdb_ingester)
-    error_signal_response_to_eit_detuning.deviceProperties.update({'conversion_factor', 'unit'})
+    error_signal_response_to_eit_detuning = BasicInstrument(
+        device_nickname=".".join(
+            [app_nickname, "error_signal_response_to_eit_detuning"]
+        ),
+        tsdb_ingester=tsdb_ingester,
+    )
+    error_signal_response_to_eit_detuning.deviceProperties.update(
+        {"conversion_factor", "unit"}
+    )
     error_signal_response_to_eit_detuning.conversion_factor = None
-    error_signal_response_to_eit_detuning.unit = 'V_per_Hz'
-    ai['error_signal_response_to_eit_detuning']=error_signal_response_to_eit_detuning
-
-    B_control_voltage_to_eit_detuning = BasicInstrument(device_nickname='.'.join([app_nickname, 'B_control_voltage_to_eit_detuning']), tsdb_ingester=tsdb_ingester)
-    B_control_voltage_to_eit_detuning.deviceProperties.update({'conversion_factor', 'unit'})
+    error_signal_response_to_eit_detuning.unit = "V_per_Hz"
+    ai["error_signal_response_to_eit_detuning"] = error_signal_response_to_eit_detuning
+
+    B_control_voltage_to_eit_detuning = BasicInstrument(
+        device_nickname=".".join([app_nickname, "B_control_voltage_to_eit_detuning"]),
+        tsdb_ingester=tsdb_ingester,
+    )
+    B_control_voltage_to_eit_detuning.deviceProperties.update(
+        {"conversion_factor", "unit"}
+    )
     B_control_voltage_to_eit_detuning.conversion_factor = None
-    B_control_voltage_to_eit_detuning.unit = 'Hz_per_V'
-    ai['B_control_voltage_to_eit_detuning'] = B_control_voltage_to_eit_detuning
-
+    B_control_voltage_to_eit_detuning.unit = "Hz_per_V"
+    ai["B_control_voltage_to_eit_detuning"] = B_control_voltage_to_eit_detuning
 
     SweepSpan = 10000
-    ai['rfgen'].stopFrequencySweep()
+    ai["rfgen"].stopFrequencySweep()
     # ai['rfgen'].setFreqFixed(freqDeltaMm2)
     # ai['rfgen'].setFreqFixed(freqZero)
     apparatus.setRFreq(freqDeltaMp2)
     # apparatus.setRFreq(freqZero)
 
-    rfPstart = -10 
+    rfPstart = -10
     rfPstop = 10
     rfPowerList = np.linspace(rfPstart, rfPstop, 11)
     rfPower0 = rfPstart
-    rfPower0 = 9 
+    rfPower0 = 9
     apparatus.setRFAmplitude(rfPower0)
 
-    d=getConfig(apparatus)
-    instruments_config=gui.QOLDictionary(a=wp, name='Instruments configs', container=d)
-    extra_tags={}
+    d = getConfig(apparatus)
+    instruments_config = gui.QOLDictionary(
+        a=wp, name="Instruments configs", container=d
+    )
+    extra_tags = {}
 
     await initial_lock_to_eit(apparatus, extra_tags=extra_tags)
 
-    lockin_slope= await calibratingLockin(apparatus, extra_tags=extra_tags)
+    lockin_slope = await calibratingLockin(apparatus, extra_tags=extra_tags)
     instruments_config.container = getConfig(apparatus)
     instruments_config.display_container_dictionary()
 
-    B_response= await responseToChangeOfBfieldControlVoltage(apparatus, extra_tags=extra_tags)
+    B_response = await responseToChangeOfBfieldControlVoltage(
+        apparatus, extra_tags=extra_tags
+    )
     instruments_config.container = getConfig(apparatus)
     instruments_config.display_container_dictionary()
 
@@ -399,10 +439,9 @@ async def main():
 
     await record_magnetometer_noise(apparatus)
 
-
     await longTermLock(apparatus, extra_tags=extra_tags)
 
-    apparatus.state = 'Done working with hardware'
+    apparatus.state = "Done working with hardware"
     logger.info(apparatus.state)
     update_webpage(apparatus=apparatus)
 
@@ -410,26 +449,30 @@ async def main():
     task_wp_update_loop.cancel()
     logger.info("exiting main loop")
     update_webpage(apparatus=apparatus)
-    return(apparatus)
+    return apparatus
+
 
 def update_webpage(byWhom=None, apparatus=None):
     timestr = time.strftime("%a, %d %b %Y, %H:%M:%S", time.localtime())
-    clock_upd.text = f'Last update at {timestr}' 
+    clock_upd.text = f"Last update at {timestr}"
     try:
         status_line.text = apparatus.state
     except:
         pass
     jp.run_task(wp.update())
 
+
 async def update_webpage_loop(update_interval=1):
     while True:
         update_webpage()
         await asyncio.sleep(update_interval)
 
+
 async def getPage():
     return wp
 
-async def  jp_startup():
+
+async def jp_startup():
     jp.run_task(main())
 
 
@@ -440,95 +483,100 @@ class Apparatus(BasicInstrument):
 
     @BasicInstrument.tsdb_append
     def getBCurrent(self):
-        scope = self.instruments['scope.monitor']
-        ch=scope.getTrace(2, decimate=False)
-        bCurrent = np.mean(ch.y.values); # mV -> mA
+        scope = self.instruments["scope.monitor"]
+        ch = scope.getTrace(2, decimate=False)
+        bCurrent = np.mean(ch.y.values)
+        # mV -> mA
         return bCurrent
 
     def getErrAndEit(self):
-        scope = self.instruments['scope.feedback']
+        scope = self.instruments["scope.feedback"]
         # we need to freeze scope since this two values are taken on the same scope
         trg_mode = scope.getTriggerMode()
-        scope.setTriggerMode('STOP')
+        scope.setTriggerMode("STOP")
         err = self.getErr()
         eit = self.getEIT()
         scope.setTriggerMode(trg_mode)
-        return(err,eit)
-
-
+        return (err, eit)
 
     @BasicInstrument.tsdb_append
     def getErr(self):
-        scope = self.instruments['scope.feedback']
-        ch1=scope.getTrace(1, decimate=False)
+        scope = self.instruments["scope.feedback"]
+        ch1 = scope.getTrace(1, decimate=False)
         err = np.mean(ch1.y.values)
         return err
 
     @BasicInstrument.tsdb_append
     def getEIT(self):
-        scope = self.instruments['scope.feedback']
-        ch3=scope.getTrace(3, decimate=False)
+        scope = self.instruments["scope.feedback"]
+        ch3 = scope.getTrace(3, decimate=False)
         eit = np.mean(ch3.y.values)
         return eit
 
     @BasicInstrument.tsdb_append
     def setFeefback(self, val):
         freq0 = self.getRFreq()
-        self.setRFreq(freq0+val)
+        self.setRFreq(freq0 + val)
 
     @BasicInstrument.tsdb_append
     def getRFreq(self):
-        rfgen = self.instruments['rfgen']
+        rfgen = self.instruments["rfgen"]
         return rfgen.getFreqFixed()
 
     @BasicInstrument.tsdb_append
-    def setRFreq(self,val):
-        rfgen = self.instruments['rfgen']
+    def setRFreq(self, val):
+        rfgen = self.instruments["rfgen"]
         rfgen.setFreqFixed(val)
 
     @BasicInstrument.tsdb_append
     def getRFAmplitude(self):
-        rfgen = self.instruments['rfgen']
+        rfgen = self.instruments["rfgen"]
         return rfgen.getRFAmplitude()
 
     @BasicInstrument.tsdb_append
     def setRFAmplitude(self, val):
-        rfgen = self.instruments['rfgen']
+        rfgen = self.instruments["rfgen"]
         return rfgen.setRFAmplitude(val)
 
     @BasicInstrument.tsdb_append
     def setLockinSlope(self, val):
-        self.lockin_slope=val
+        self.lockin_slope = val
 
 
-if __name__ == '__main__': 
-    logger.info('========== Start up ===========')
-    tsdb_client = tsdb.Client('influx', 'http://lumus.physics.wm.edu:8428', database='qolab')
-    tsdb_ingester = tsdb.Ingester(tsdb_client, batch=11, measurement_prefix='VAMPIRE.HighPower')
+if __name__ == "__main__":
+    logger.info("========== Start up ===========")
+    tsdb_client = tsdb.Client(
+        "influx", "http://lumus.physics.wm.edu:8428", database="qolab"
+    )
+    tsdb_ingester = tsdb.Ingester(
+        tsdb_client, batch=11, measurement_prefix="VAMPIRE.HighPower"
+    )
 
     wp = jp.WebPage(delete_flag=False)
-    apparatus = Apparatus(tsdb_ingester=tsdb_ingester, device_nickname='magnetometer',)
-    apparatus.config['Device type'] = 'QOL VAMPIRE HighPower magnetometer'
-    apparatus.config['Device model'] = 'v0.1'
-    apparatus.config['FnamePrefix'] = 'magnetometer'
-    apparatus.config['SavePath'] = '/mnt/qol_grp_data/data.VAMPIRE.HighPower'
+    apparatus = Apparatus(
+        tsdb_ingester=tsdb_ingester,
+        device_nickname="magnetometer",
+    )
+    apparatus.config["Device type"] = "QOL VAMPIRE HighPower magnetometer"
+    apparatus.config["Device model"] = "v0.1"
+    apparatus.config["FnamePrefix"] = "magnetometer"
+    apparatus.config["SavePath"] = "/mnt/qol_grp_data/data.VAMPIRE.HighPower"
     # apparatus.config['SavePath'] = './data'
 
-    d=jp.Div(text='Magnetometer log', a=wp, classes='text-white bg-blue-500 text-center text-xl')
+    d = jp.Div(
+        text="Magnetometer log",
+        a=wp,
+        classes="text-white bg-blue-500 text-center text-xl",
+    )
 
-    div_status = jp.Div(classes='text-xl flex m0 p-1 space-x-4 bg-gray-300 font-mono', a=wp)
-    clock_upd = jp.Div(text='Clock Loading...', classes='text-xl bg-gray-400', a=div_status)
-    status_line = jp.Div(text='Status Loading...',classes='text-xl', a=div_status)
+    div_status = jp.Div(
+        classes="text-xl flex m0 p-1 space-x-4 bg-gray-300 font-mono", a=wp
+    )
+    clock_upd = jp.Div(
+        text="Clock Loading...", classes="text-xl bg-gray-400", a=div_status
+    )
+    status_line = jp.Div(text="Status Loading...", classes="text-xl", a=div_status)
 
     # mpl.use("TkAgg")
     # apparatus = asyncio.run(main())
     jp.justpy(getPage, startup=jp_startup)
-
-
-
-
-
-
-    
-
-