Full Code of Galvant/InstrumentKit for AI

gitextract_gysdejrm/

├── .coveragerc
├── .github/
│   └── workflows/
│       ├── deploy.yml
│       └── test.yml
├── .gitignore
├── .pre-commit-config.yaml
├── .readthedocs.yml
├── README.rst
├── doc/
│   ├── Makefile
│   ├── examples/
│   │   ├── .ipynb_checkpoints/
│   │   │   └── ex_keithley6514-checkpoint.ipynb
│   │   ├── ex_generic_scpi.ipynb
│   │   ├── ex_generic_scpi.py
│   │   ├── ex_hp3325.py
│   │   ├── ex_hp3456.out
│   │   ├── ex_hp3456.py
│   │   ├── ex_keithley195.ipynb
│   │   ├── ex_keithley195.py
│   │   ├── ex_keithley6514.ipynb
│   │   ├── ex_maui.ipynb
│   │   ├── ex_oscilloscope_waveform.ipynb
│   │   ├── ex_oscilloscope_waveform.py
│   │   ├── ex_qubitekk_gui.py
│   │   ├── ex_qubitekkcc.py
│   │   ├── ex_qubitekkcc_simple.py
│   │   ├── ex_tekdpo70000.ipynb
│   │   ├── ex_thorlabslcc.py
│   │   ├── ex_thorlabssc10.py
│   │   ├── ex_thorlabstc200.py
│   │   ├── ex_topticatopmode.py
│   │   ├── example2.py
│   │   ├── minghe/
│   │   │   └── ex_minghe_mhs5200.py
│   │   ├── qubitekk/
│   │   │   └── ex_qubitekk_mc1.py
│   │   ├── srs_DG645.ipynb
│   │   └── srs_DG645.py
│   ├── make.bat
│   └── source/
│       ├── acknowledgements.rst
│       ├── apiref/
│       │   ├── agilent.rst
│       │   ├── aimtti.rst
│       │   ├── comet.rst
│       │   ├── config.rst
│       │   ├── delta_elektronika.rst
│       │   ├── dressler.rst
│       │   ├── fluke.rst
│       │   ├── generic_scpi.rst
│       │   ├── gentec-eo.rst
│       │   ├── glassman.rst
│       │   ├── hcp.rst
│       │   ├── holzworth.rst
│       │   ├── hp.rst
│       │   ├── index.rst
│       │   ├── instrument.rst
│       │   ├── keithley.rst
│       │   ├── lakeshore.rst
│       │   ├── mettler_toledo.rst
│       │   ├── minghe.rst
│       │   ├── newport.rst
│       │   ├── ondax.rst
│       │   ├── oxford.rst
│       │   ├── pfeiffer.rst
│       │   ├── phasematrix.rst
│       │   ├── picowatt.rst
│       │   ├── qubitekk.rst
│       │   ├── rigol.rst
│       │   ├── srs.rst
│       │   ├── sunpower.rst
│       │   ├── tektronix.rst
│       │   ├── teledyne.rst
│       │   ├── thorlabs.rst
│       │   ├── toptica.rst
│       │   └── yokogawa.rst
│       ├── conf.py
│       ├── devguide/
│       │   ├── code_style.rst
│       │   ├── design_philosophy.rst
│       │   ├── index.rst
│       │   ├── testing.rst
│       │   └── util_fns.rst
│       ├── index.rst
│       └── intro.rst
├── license/
│   ├── AUTHOR.TXT
│   └── LICENSE.TXT
├── matlab/
│   ├── matlab-example.ipynb
│   └── open_instrument.m
├── pyproject.toml
├── src/
│   └── instruments/
│       ├── __init__.py
│       ├── abstract_instruments/
│       │   ├── __init__.py
│       │   ├── comm/
│       │   │   ├── __init__.py
│       │   │   ├── abstract_comm.py
│       │   │   ├── file_communicator.py
│       │   │   ├── gpib_communicator.py
│       │   │   ├── loopback_communicator.py
│       │   │   ├── serial_communicator.py
│       │   │   ├── serial_manager.py
│       │   │   ├── socket_communicator.py
│       │   │   ├── usb_communicator.py
│       │   │   ├── usbtmc_communicator.py
│       │   │   ├── visa_communicator.py
│       │   │   └── vxi11_communicator.py
│       │   ├── electrometer.py
│       │   ├── function_generator.py
│       │   ├── instrument.py
│       │   ├── multimeter.py
│       │   ├── optical_spectrum_analyzer.py
│       │   ├── oscilloscope.py
│       │   ├── power_supply.py
│       │   └── signal_generator/
│       │       ├── __init__.py
│       │       ├── channel.py
│       │       ├── signal_generator.py
│       │       └── single_channel_sg.py
│       ├── agilent/
│       │   ├── __init__.py
│       │   ├── agilent33220a.py
│       │   └── agilent34410a.py
│       ├── aimtti/
│       │   ├── __init__.py
│       │   └── aimttiel302p.py
│       ├── comet/
│       │   ├── __init__.py
│       │   └── cito_plus_1310.py
│       ├── config.py
│       ├── delta_elektronika/
│       │   ├── __init__.py
│       │   └── psc_eth.py
│       ├── dressler/
│       │   ├── __init__.py
│       │   └── cesar_1312.py
│       ├── errors.py
│       ├── fluke/
│       │   ├── __init__.py
│       │   └── fluke3000.py
│       ├── generic_scpi/
│       │   ├── __init__.py
│       │   ├── scpi_function_generator.py
│       │   ├── scpi_instrument.py
│       │   └── scpi_multimeter.py
│       ├── gentec_eo/
│       │   ├── __init__.py
│       │   └── blu.py
│       ├── glassman/
│       │   ├── __init__.py
│       │   └── glassmanfr.py
│       ├── hcp/
│       │   ├── __init__.py
│       │   ├── tc038.py
│       │   └── tc038d.py
│       ├── holzworth/
│       │   ├── __init__.py
│       │   └── holzworth_hs9000.py
│       ├── hp/
│       │   ├── __init__.py
│       │   ├── hp3325a.py
│       │   ├── hp3456a.py
│       │   ├── hp6624a.py
│       │   ├── hp6632b.py
│       │   ├── hp6652a.py
│       │   └── hpe3631a.py
│       ├── keithley/
│       │   ├── __init__.py
│       │   ├── keithley195.py
│       │   ├── keithley2182.py
│       │   ├── keithley485.py
│       │   ├── keithley580.py
│       │   ├── keithley6220.py
│       │   └── keithley6514.py
│       ├── lakeshore/
│       │   ├── __init__.py
│       │   ├── lakeshore336.py
│       │   ├── lakeshore340.py
│       │   ├── lakeshore370.py
│       │   └── lakeshore475.py
│       ├── mettler_toledo/
│       │   ├── __init__.py
│       │   └── mt_sics.py
│       ├── minghe/
│       │   ├── __init__.py
│       │   └── mhs5200a.py
│       ├── named_struct.py
│       ├── newport/
│       │   ├── __init__.py
│       │   ├── agilis.py
│       │   ├── errors.py
│       │   ├── newport_pmc8742.py
│       │   └── newportesp301.py
│       ├── ondax/
│       │   ├── __init__.py
│       │   └── lm.py
│       ├── optional_dep_finder.py
│       ├── oxford/
│       │   ├── __init__.py
│       │   └── oxforditc503.py
│       ├── pfeiffer/
│       │   ├── __init__.py
│       │   └── tpg36x.py
│       ├── phasematrix/
│       │   ├── __init__.py
│       │   └── phasematrix_fsw0020.py
│       ├── picowatt/
│       │   ├── __init__.py
│       │   └── picowattavs47.py
│       ├── qubitekk/
│       │   ├── __init__.py
│       │   ├── cc1.py
│       │   └── mc1.py
│       ├── rigol/
│       │   ├── __init__.py
│       │   └── rigolds1000.py
│       ├── srs/
│       │   ├── __init__.py
│       │   ├── srs345.py
│       │   ├── srs830.py
│       │   ├── srsctc100.py
│       │   └── srsdg645.py
│       ├── sunpower/
│       │   ├── __init__.py
│       │   └── cryotel_gt.py
│       ├── tektronix/
│       │   ├── __init__.py
│       │   ├── tekawg2000.py
│       │   ├── tekdpo4104.py
│       │   ├── tekdpo70000.py
│       │   ├── tektds224.py
│       │   └── tektds5xx.py
│       ├── teledyne/
│       │   ├── __init__.py
│       │   └── maui.py
│       ├── thorlabs/
│       │   ├── __init__.py
│       │   ├── _abstract.py
│       │   ├── _cmds.py
│       │   ├── _packets.py
│       │   ├── lcc25.py
│       │   ├── pm100usb.py
│       │   ├── sc10.py
│       │   ├── tc200.py
│       │   ├── thorlabs_utils.py
│       │   └── thorlabsapt.py
│       ├── toptica/
│       │   ├── __init__.py
│       │   ├── topmode.py
│       │   └── toptica_utils.py
│       ├── units.py
│       ├── util_fns.py
│       └── yokogawa/
│           ├── __init__.py
│           ├── yokogawa6370.py
│           └── yokogawa7651.py
├── tests/
│   ├── __init__.py
│   ├── test_abstract_inst/
│   │   ├── __init__.py
│   │   ├── test_electrometer.py
│   │   ├── test_function_generator.py
│   │   ├── test_multimeter.py
│   │   ├── test_optical_spectrum_analyzer.py
│   │   ├── test_oscilloscope.py
│   │   ├── test_power_supply.py
│   │   └── test_signal_generator/
│   │       ├── test_channel.py
│   │       ├── test_signal_generator.py
│   │       └── test_single_channel_sg.py
│   ├── test_agilent/
│   │   ├── __init__.py
│   │   ├── test_agilent_33220a.py
│   │   └── test_agilent_34410a.py
│   ├── test_aimtti/
│   │   ├── __init__.py
│   │   └── test_aimttiel302p.py
│   ├── test_base_instrument.py
│   ├── test_comet/
│   │   ├── __init__.py
│   │   └── test_cito_plus_1310.py
│   ├── test_comm/
│   │   ├── __init__.py
│   │   ├── test_file.py
│   │   ├── test_gpibusb.py
│   │   ├── test_loopback.py
│   │   ├── test_serial.py
│   │   ├── test_socket.py
│   │   ├── test_usb_communicator.py
│   │   ├── test_usbtmc.py
│   │   ├── test_visa_communicator.py
│   │   └── test_vxi11.py
│   ├── test_config.py
│   ├── test_delta_elektronika/
│   │   ├── __init__.py
│   │   └── test_psc_eth.py
│   ├── test_dressler/
│   │   ├── __init__.py
│   │   └── test_cesar_1312.py
│   ├── test_fluke/
│   │   ├── __init__.py
│   │   └── test_fluke3000.py
│   ├── test_generic_scpi/
│   │   ├── __init__.py
│   │   ├── test_scpi_function_generator.py
│   │   ├── test_scpi_instrument.py
│   │   └── test_scpi_multimeter.py
│   ├── test_gentec_eo/
│   │   ├── __init__.py
│   │   └── test_blu.py
│   ├── test_glassman/
│   │   ├── __init__.py
│   │   └── test_glassmanfr.py
│   ├── test_hcp/
│   │   ├── __init__.py
│   │   ├── test_tc038.py
│   │   └── test_tc038d.py
│   ├── test_holzworth/
│   │   ├── __init__.py
│   │   └── test_holzworth_hs9000.py
│   ├── test_hp/
│   │   ├── __init__.py
│   │   ├── test_hp3325a.py
│   │   ├── test_hp3456a.py
│   │   ├── test_hp6624a.py
│   │   ├── test_hp6632b.py
│   │   ├── test_hp6652a.py
│   │   └── test_hpe3631a.py
│   ├── test_keithley/
│   │   ├── __init__.py
│   │   ├── test_keithley195.py
│   │   ├── test_keithley2182.py
│   │   ├── test_keithley485.py
│   │   ├── test_keithley580.py
│   │   ├── test_keithley6220.py
│   │   └── test_keithley6514.py
│   ├── test_lakeshore/
│   │   ├── __init__.py
│   │   ├── test_lakeshore336.py
│   │   ├── test_lakeshore340.py
│   │   ├── test_lakeshore370.py
│   │   └── test_lakeshore475.py
│   ├── test_mettler_toledo/
│   │   ├── __init__.py
│   │   └── test_mt_sics.py
│   ├── test_minghe/
│   │   └── test_minghe_mhs5200a.py
│   ├── test_named_struct.py
│   ├── test_newport/
│   │   ├── __init__.py
│   │   ├── test_agilis.py
│   │   ├── test_errors.py
│   │   ├── test_newport_pmc8742.py
│   │   └── test_newportesp301.py
│   ├── test_ondax/
│   │   └── test_lm.py
│   ├── test_oxford/
│   │   ├── __init__.py
│   │   └── test_oxforditc503.py
│   ├── test_package.py
│   ├── test_pfeiffer/
│   │   ├── __init__.py
│   │   └── test_tpg36x.py
│   ├── test_phasematrix/
│   │   ├── __init__.py
│   │   └── test_phasematrix_fsw0020.py
│   ├── test_picowatt/
│   │   ├── __init__.py
│   │   └── test_picowatt_avs47.py
│   ├── test_property_factories/
│   │   ├── __init__.py
│   │   ├── test_bool_property.py
│   │   ├── test_bounded_unitful_property.py
│   │   ├── test_enum_property.py
│   │   ├── test_int_property.py
│   │   ├── test_rproperty.py
│   │   ├── test_string_property.py
│   │   ├── test_unitful_property.py
│   │   └── test_unitless_property.py
│   ├── test_qubitekk/
│   │   ├── __init__.py
│   │   ├── test_qubitekk_cc1.py
│   │   └── test_qubitekk_mc1.py
│   ├── test_rigol/
│   │   └── test_rigolds1000.py
│   ├── test_split_str.py
│   ├── test_srs/
│   │   ├── __init__.py
│   │   ├── test_srs345.py
│   │   ├── test_srs830.py
│   │   ├── test_srsctc100.py
│   │   └── test_srsdg645.py
│   ├── test_sunpower/
│   │   ├── __init__.py
│   │   └── test_cryotel_gt.py
│   ├── test_tektronix/
│   │   ├── __init__.py
│   │   ├── test_tekawg2000.py
│   │   ├── test_tekdpo4104.py
│   │   ├── test_tekdpo70000.py
│   │   ├── test_tektronix_tds224.py
│   │   └── test_tktds5xx.py
│   ├── test_teledyne/
│   │   ├── __init__.py
│   │   └── test_maui.py
│   ├── test_test_utils.py
│   ├── test_thorlabs/
│   │   ├── __init__.py
│   │   ├── test_abstract.py
│   │   ├── test_packets.py
│   │   ├── test_thorlabs_apt.py
│   │   ├── test_thorlabs_lcc25.py
│   │   ├── test_thorlabs_pm100usb.py
│   │   ├── test_thorlabs_sc10.py
│   │   ├── test_thorlabs_tc200.py
│   │   └── test_utils.py
│   ├── test_toptica/
│   │   ├── __init__.py
│   │   ├── test_toptica_topmode.py
│   │   └── test_toptica_utils.py
│   ├── test_util_fns.py
│   └── test_yokogawa/
│       ├── __init__.py
│       ├── test_yokogawa7651.py
│       └── test_yokogawa_6370.py
└── tox.ini

SYMBOL INDEX (3771 symbols across 199 files)

FILE: doc/examples/ex_qubitekk_gui.py
  function clear_counts (line 21) | def clear_counts(*args):
  function getvalues (line 25) | def getvalues(i):
  function gate_enable (line 55) | def gate_enable():
  function subtract_enable (line 62) | def subtract_enable():
  function trigger_enable (line 69) | def trigger_enable():
  function parse (line 76) | def parse(*args):
  function reset (line 81) | def reset(*args):

FILE: doc/examples/ex_qubitekkcc.py
  function main (line 8) | def main():

FILE: src/instruments/abstract_instruments/comm/abstract_comm.py
  class AbstractCommunicator (line 16) | class AbstractCommunicator(metaclass=abc.ABCMeta):
    method __init__ (line 26) | def __init__(self, *args, **kwargs):  # pylint: disable=unused-argument
    method __repr__ (line 38) | def __repr__(self):
    method debug (line 48) | def debug(self):
    method debug (line 66) | def debug(self, newval):
    method address (line 73) | def address(self):
    method address (line 81) | def address(self, newval):
    method terminator (line 86) | def terminator(self):
    method terminator (line 94) | def terminator(self, newval):
    method timeout (line 99) | def timeout(self):
    method timeout (line 107) | def timeout(self, newval):
    method read_raw (line 113) | def read_raw(self, size=-1):
    method write_raw (line 125) | def write_raw(self, msg):
    method _sendcmd (line 134) | def _sendcmd(self, msg):
    method _query (line 144) | def _query(self, msg, size=-1):
    method flush_input (line 160) | def flush_input(self):
    method write (line 169) | def write(self, msg, encoding="utf-8"):
    method read (line 183) | def read(self, size=-1, encoding="utf-8"):
    method sendcmd (line 206) | def sendcmd(self, msg):
    method query (line 219) | def query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/file_communicator.py
  class FileCommunicator (line 22) | class FileCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 35) | def __init__(self, filelike):
    method address (line 47) | def address(self):
    method address (line 60) | def address(self, newval):
    method terminator (line 66) | def terminator(self):
    method terminator (line 75) | def terminator(self, newval):
    method timeout (line 86) | def timeout(self):
    method timeout (line 94) | def timeout(self, newval):
    method close (line 99) | def close(self):
    method read_raw (line 108) | def read_raw(self, size=-1):
    method write_raw (line 130) | def write_raw(self, msg):
    method seek (line 138) | def seek(self, offset):
    method tell (line 148) | def tell(self):
    method flush_input (line 156) | def flush_input(self):
    method _sendcmd (line 166) | def _sendcmd(self, msg):
    method _query (line 182) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/gpib_communicator.py
  class GPIBCommunicator (line 22) | class GPIBCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 32) | def __init__(self, filelike, gpib_address, model="gi"):
    class Model (line 53) | class Model(Enum):
    method address (line 66) | def address(self):
    method address (line 83) | def address(self, newval):
    method timeout (line 95) | def timeout(self):
    method timeout (line 106) | def timeout(self, newval):
    method terminator (line 118) | def terminator(self):
    method terminator (line 134) | def terminator(self, newval):
    method eoi (line 176) | def eoi(self):
    method eoi (line 195) | def eoi(self, newval):
    method eos (line 205) | def eos(self):
    method eos (line 219) | def eos(self, newval):
    method close (line 246) | def close(self):
    method read_raw (line 254) | def read_raw(self, size=-1):
    method read (line 266) | def read(self, size=-1, encoding="utf-8"):
    method write_raw (line 285) | def write_raw(self, msg):
    method write (line 294) | def write(self, msg, encoding="utf-8"):
    method flush_input (line 304) | def flush_input(self):
    method _sendcmd (line 313) | def _sendcmd(self, msg):
    method _query (line 340) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/loopback_communicator.py
  class LoopbackCommunicator (line 18) | class LoopbackCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 26) | def __init__(self, stdin=None, stdout=None):
    method address (line 35) | def address(self):
    method address (line 44) | def address(self, newval):
    method terminator (line 48) | def terminator(self):
    method terminator (line 59) | def terminator(self, newval):
    method timeout (line 70) | def timeout(self):
    method timeout (line 80) | def timeout(self, newval):
    method close (line 85) | def close(self):
    method read_raw (line 95) | def read_raw(self, size=-1):
    method write_raw (line 127) | def write_raw(self, msg):
    method seek (line 140) | def seek(self, offset):  # pylint: disable=unused-argument,no-self-use
    method tell (line 148) | def tell(self):  # pylint: disable=no-self-use
    method flush_input (line 156) | def flush_input(self):
    method _sendcmd (line 165) | def _sendcmd(self, msg):
    method _query (line 178) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/serial_communicator.py
  class SerialCommunicator (line 21) | class SerialCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 27) | def __init__(self, conn):
    method address (line 40) | def address(self):
    method address (line 49) | def address(self, newval):
    method terminator (line 56) | def terminator(self):
    method terminator (line 67) | def terminator(self, newval):
    method timeout (line 78) | def timeout(self):
    method timeout (line 88) | def timeout(self, newval):
    method parity (line 93) | def parity(self):
    method parity (line 102) | def parity(self, newval):
    method close (line 107) | def close(self):
    method read_raw (line 116) | def read_raw(self, size=-1):
    method write_raw (line 146) | def write_raw(self, msg):
    method seek (line 154) | def seek(self, offset):  # pylint: disable=unused-argument,no-self-use
    method tell (line 162) | def tell(self):  # pylint: disable=no-self-use
    method flush_input (line 170) | def flush_input(self):
    method _sendcmd (line 181) | def _sendcmd(self, msg):
    method _query (line 193) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/serial_manager.py
  function new_serial_connection (line 33) | def new_serial_connection(port, baud=460800, timeout=3, write_timeout=3,...

FILE: src/instruments/abstract_instruments/comm/socket_communicator.py
  class SocketCommunicator (line 21) | class SocketCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 29) | def __init__(self, conn):
    method address (line 45) | def address(self):
    method address (line 52) | def address(self, newval):
    method terminator (line 56) | def terminator(self):
    method terminator (line 60) | def terminator(self, newval):
    method timeout (line 71) | def timeout(self):
    method timeout (line 81) | def timeout(self, newval):
    method close (line 87) | def close(self):
    method read_raw (line 96) | def read_raw(self, size=-1):
    method write_raw (line 121) | def write_raw(self, msg):
    method seek (line 130) | def seek(self, offset):  # pylint: disable=unused-argument,no-self-use
    method tell (line 138) | def tell(self):  # pylint: disable=no-self-use
    method flush_input (line 146) | def flush_input(self):
    method _sendcmd (line 155) | def _sendcmd(self, msg):
    method _query (line 167) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/usb_communicator.py
  class USBCommunicator (line 22) | class USBCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 33) | def __init__(self, dev):
    method address (line 77) | def address(self):
    method address (line 81) | def address(self, _):
    method terminator (line 85) | def terminator(self):
    method terminator (line 94) | def terminator(self, newval):
    method timeout (line 103) | def timeout(self):
    method timeout (line 113) | def timeout(self, newval):
    method close (line 119) | def close(self):
    method read_raw (line 126) | def read_raw(self, size=-1):
    method write_raw (line 147) | def write_raw(self, msg):
    method seek (line 155) | def seek(self, offset):  # pylint: disable=unused-argument,no-self-use
    method tell (line 158) | def tell(self):  # pylint: disable=no-self-use
    method flush_input (line 161) | def flush_input(self):
    method _sendcmd (line 170) | def _sendcmd(self, msg):
    method _query (line 182) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/usbtmc_communicator.py
  class USBTMCCommunicator (line 21) | class USBTMCCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 26) | def __init__(self, *args, **kwargs):
    method address (line 37) | def address(self):
    method terminator (line 44) | def terminator(self):
    method terminator (line 54) | def terminator(self, newval):
    method timeout (line 66) | def timeout(self):
    method timeout (line 76) | def timeout(self, newval):
    method close (line 82) | def close(self):
    method read (line 91) | def read(self, size=-1, encoding="utf-8"):
    method read_raw (line 105) | def read_raw(self, size=-1):
    method write (line 117) | def write(self, msg, encoding="utf-8"):
    method write_raw (line 129) | def write_raw(self, msg):
    method seek (line 138) | def seek(self, offset):
    method tell (line 141) | def tell(self):
    method flush_input (line 144) | def flush_input(self):
    method _sendcmd (line 152) | def _sendcmd(self, msg):
    method _query (line 163) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/visa_communicator.py
  class VisaCommunicator (line 21) | class VisaCommunicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 27) | def __init__(self, conn):
    method address (line 49) | def address(self):
    method address (line 58) | def address(self, newval):
    method read_termination (line 64) | def read_termination(self):
    method read_termination (line 69) | def read_termination(self, newval):
    method terminator (line 77) | def terminator(self):
    method terminator (line 86) | def terminator(self, newval):
    method timeout (line 96) | def timeout(self):
    method timeout (line 100) | def timeout(self, newval):
    method write_termination (line 105) | def write_termination(self):
    method write_termination (line 110) | def write_termination(self, newval):
    method close (line 119) | def close(self):
    method read_raw (line 128) | def read_raw(self, size=-1):
    method write_raw (line 155) | def write_raw(self, msg):
    method seek (line 164) | def seek(self, offset):  # pylint: disable=unused-argument,no-self-use
    method tell (line 167) | def tell(self):  # pylint: disable=no-self-use
    method flush_input (line 170) | def flush_input(self):
    method _sendcmd (line 179) | def _sendcmd(self, msg):
    method _query (line 191) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/comm/vxi11_communicator.py
  class VXI11Communicator (line 23) | class VXI11Communicator(io.IOBase, AbstractCommunicator):
    method __init__ (line 40) | def __init__(self, *args, **kwargs):
    method address (line 53) | def address(self):
    method terminator (line 63) | def terminator(self):
    method terminator (line 74) | def terminator(self, newval):
    method timeout (line 91) | def timeout(self):
    method timeout (line 101) | def timeout(self, newval):
    method close (line 106) | def close(self):
    method read_raw (line 115) | def read_raw(self, size=-1):
    method write_raw (line 125) | def write_raw(self, msg):
    method seek (line 133) | def seek(self, offset):
    method tell (line 141) | def tell(self):
    method flush_input (line 149) | def flush_input(self):
    method _sendcmd (line 160) | def _sendcmd(self, msg):
    method _query (line 171) | def _query(self, msg, size=-1):

FILE: src/instruments/abstract_instruments/electrometer.py
  class Electrometer (line 16) | class Electrometer(Instrument, metaclass=abc.ABCMeta):
    method mode (line 28) | def mode(self):
    method mode (line 38) | def mode(self, newval):
    method unit (line 43) | def unit(self):
    method trigger_mode (line 53) | def trigger_mode(self):
    method trigger_mode (line 63) | def trigger_mode(self, newval):
    method input_range (line 68) | def input_range(self):
    method input_range (line 78) | def input_range(self, newval):
    method zero_check (line 83) | def zero_check(self):
    method zero_check (line 93) | def zero_check(self, newval):
    method zero_correct (line 98) | def zero_correct(self):
    method zero_correct (line 108) | def zero_correct(self, newval):
    method fetch (line 114) | def fetch(self):
    method read_measurements (line 122) | def read_measurements(self):

FILE: src/instruments/abstract_instruments/function_generator.py
  class FunctionGenerator (line 21) | class FunctionGenerator(Instrument, metaclass=abc.ABCMeta):
    method __init__ (line 29) | def __init__(self, filelike):
    class Channel (line 34) | class Channel(metaclass=abc.ABCMeta):
      method __init__ (line 49) | def __init__(self, parent, name):
      method frequency (line 56) | def frequency(self):
      method frequency (line 69) | def frequency(self, newval):
      method function (line 76) | def function(self):
      method function (line 89) | def function(self, newval):
      method offset (line 96) | def offset(self):
      method offset (line 109) | def offset(self, newval):
      method phase (line 116) | def phase(self):
      method phase (line 129) | def phase(self, newval):
      method _get_amplitude_ (line 135) | def _get_amplitude_(self):
      method _set_amplitude_ (line 141) | def _set_amplitude_(self, magnitude, units):
      method amplitude (line 148) | def amplitude(self):
      method amplitude (line 173) | def amplitude(self, newval):
      method sendcmd (line 193) | def sendcmd(self, cmd):
      method query (line 196) | def query(self, cmd, size=-1):
    class VoltageMode (line 201) | class VoltageMode(Enum):
    class Function (line 210) | class Function(Enum):
    method channel (line 223) | def channel(self):
    method amplitude (line 238) | def amplitude(self):
    method amplitude (line 248) | def amplitude(self, newval):
    method _get_amplitude_ (line 251) | def _get_amplitude_(self):
    method _set_amplitude_ (line 254) | def _set_amplitude_(self, magnitude, units):
    method frequency (line 258) | def frequency(self):
    method frequency (line 271) | def frequency(self, newval):
    method function (line 278) | def function(self):
    method function (line 291) | def function(self, newval):
    method offset (line 298) | def offset(self):
    method offset (line 311) | def offset(self, newval):
    method phase (line 318) | def phase(self):
    method phase (line 331) | def phase(self, newval):

FILE: src/instruments/abstract_instruments/instrument.py
  class Instrument (line 44) | class Instrument:
    method __init__ (line 52) | def __init__(self, filelike, *args, **kwargs):
    method _ack_expected (line 71) | def _ack_expected(self, msg=""):  # pylint: disable=unused-argument,no...
    method _authenticate (line 74) | def _authenticate(self, auth):
    method sendcmd (line 83) | def sendcmd(self, cmd):
    method query (line 113) | def query(self, cmd, size=-1):
    method read (line 150) | def read(self, size=-1, encoding="utf-8"):
    method read_raw (line 162) | def read_raw(self, size=-1):
    method timeout (line 177) | def timeout(self):
    method timeout (line 188) | def timeout(self, newval):
    method address (line 192) | def address(self):
    method address (line 206) | def address(self, newval):
    method terminator (line 210) | def terminator(self):
    method terminator (line 223) | def terminator(self, newval):
    method prompt (line 227) | def prompt(self):
    method prompt (line 246) | def prompt(self, newval):
    method write (line 251) | def write(self, msg):
    method binblockread (line 267) | def binblockread(self, data_width, fmt=None):
    method open_from_uri (line 339) | def open_from_uri(cls, uri):
    method open_tcpip (line 441) | def open_tcpip(cls, host, port, auth=None):
    method open_serial (line 469) | def open_serial(
    method open_gpibusb (line 569) | def open_gpibusb(cls, port, gpib_address, timeout=3, write_timeout=3, ...
    method open_gpibethernet (line 601) | def open_gpibethernet(cls, host, port, gpib_address, model="pl"):
    method open_visa (line 620) | def open_visa(cls, resource_name):
    method open_test (line 648) | def open_test(cls, stdin=None, stdout=None):
    method open_usbtmc (line 667) | def open_usbtmc(cls, *args, **kwargs):
    method open_vxi11 (line 685) | def open_vxi11(cls, *args, **kwargs):
    method open_usb (line 700) | def open_usb(cls, vid, pid):
    method open_file (line 728) | def open_file(cls, filename):
    method __enter__ (line 742) | def __enter__(self) -> typing_extensions.Self:
    method __exit__ (line 745) | def __exit__(self, *exc):

FILE: src/instruments/abstract_instruments/multimeter.py
  class Multimeter (line 16) | class Multimeter(Instrument, metaclass=abc.ABCMeta):
    method mode (line 28) | def mode(self):
    method mode (line 38) | def mode(self, newval):
    method trigger_mode (line 43) | def trigger_mode(self):
    method trigger_mode (line 53) | def trigger_mode(self, newval):
    method relative (line 58) | def relative(self):
    method relative (line 68) | def relative(self, newval):
    method input_range (line 73) | def input_range(self):
    method input_range (line 83) | def input_range(self, newval):
    method measure (line 89) | def measure(self, mode):

FILE: src/instruments/abstract_instruments/optical_spectrum_analyzer.py
  class OpticalSpectrumAnalyzer (line 16) | class OpticalSpectrumAnalyzer(Instrument, metaclass=abc.ABCMeta):
    method __init__ (line 24) | def __init__(self, *args, **kwargs):
    class Channel (line 28) | class Channel(metaclass=abc.ABCMeta):
      method __init__ (line 43) | def __init__(self, parent, name):
      method wavelength (line 50) | def wavelength(self, bin_format=True):
      method data (line 66) | def data(self, bin_format=True):
    method channel (line 84) | def channel(self):
    method start_wl (line 93) | def start_wl(self):
    method start_wl (line 103) | def start_wl(self, newval):
    method stop_wl (line 107) | def stop_wl(self):
    method stop_wl (line 117) | def stop_wl(self, newval):
    method bandwidth (line 121) | def bandwidth(self):
    method bandwidth (line 131) | def bandwidth(self, newval):
    method start_sweep (line 137) | def start_sweep(self):
    method wavelength (line 143) | def wavelength(self, bin_format=True):
    method data (line 158) | def data(self, bin_format=True):

FILE: src/instruments/abstract_instruments/oscilloscope.py
  class Oscilloscope (line 16) | class Oscilloscope(Instrument, metaclass=abc.ABCMeta):
    class Channel (line 24) | class Channel(metaclass=abc.ABCMeta):
      method coupling (line 36) | def coupling(self):
      method coupling (line 47) | def coupling(self, newval):
    class DataSource (line 50) | class DataSource(metaclass=abc.ABCMeta):
      method __init__ (line 59) | def __init__(self, parent, name):
      method __enter__ (line 64) | def __enter__(self):
      method __exit__ (line 73) | def __exit__(self, type, value, traceback):
      method __eq__ (line 77) | def __eq__(self, other):
      method name (line 89) | def name(self):
      method read_waveform (line 100) | def read_waveform(self, bin_format=True):
    method channel (line 116) | def channel(self):
    method ref (line 126) | def ref(self):
    method math (line 136) | def math(self):
    method force_trigger (line 147) | def force_trigger(self):

FILE: src/instruments/abstract_instruments/power_supply.py
  class PowerSupply (line 15) | class PowerSupply(Instrument, metaclass=abc.ABCMeta):
    class Channel (line 23) | class Channel(metaclass=abc.ABCMeta):
      method mode (line 35) | def mode(self):
      method mode (line 45) | def mode(self, newval):
      method voltage (line 50) | def voltage(self):
      method voltage (line 60) | def voltage(self, newval):
      method current (line 65) | def current(self):
      method current (line 75) | def current(self, newval):
      method output (line 80) | def output(self):
      method output (line 90) | def output(self, newval):
    method channel (line 97) | def channel(self):
    method voltage (line 110) | def voltage(self):
    method voltage (line 120) | def voltage(self, newval):
    method current (line 125) | def current(self):
    method current (line 135) | def current(self, newval):

FILE: src/instruments/abstract_instruments/signal_generator/channel.py
  class SGChannel (line 13) | class SGChannel(metaclass=abc.ABCMeta):
    method frequency (line 26) | def frequency(self):
    method frequency (line 35) | def frequency(self, newval):
    method power (line 40) | def power(self):
    method power (line 49) | def power(self, newval):
    method phase (line 54) | def phase(self):
    method phase (line 63) | def phase(self, newval):
    method output (line 68) | def output(self):
    method output (line 77) | def output(self, newval):

FILE: src/instruments/abstract_instruments/signal_generator/signal_generator.py
  class SignalGenerator (line 16) | class SignalGenerator(Instrument, metaclass=abc.ABCMeta):
    method channel (line 30) | def channel(self):

FILE: src/instruments/abstract_instruments/signal_generator/single_channel_sg.py
  class SingleChannelSG (line 18) | class SingleChannelSG(SignalGenerator, SGChannel):
    method channel (line 35) | def channel(self):

FILE: src/instruments/agilent/agilent33220a.py
  class Agilent33220a (line 23) | class Agilent33220a(SCPIFunctionGenerator):
    class Function (line 45) | class Function(Enum):
    class LoadResistance (line 58) | class LoadResistance(Enum):
    class OutputPolarity (line 67) | class OutputPolarity(Enum):
    method load_resistance (line 151) | def load_resistance(self):
    method load_resistance (line 171) | def load_resistance(self, newval):
    method phase (line 181) | def phase(self):
    method phase (line 185) | def phase(self, newval):

FILE: src/instruments/agilent/agilent34410a.py
  class Agilent34410a (line 15) | class Agilent34410a(SCPIMultimeter):  # pylint: disable=abstract-method
    method data_point_count (line 35) | def data_point_count(self):
    method init (line 46) | def init(self):
    method abort (line 57) | def abort(self):
    method clear_memory (line 65) | def clear_memory(self):
    method r (line 71) | def r(self, count):
    method fetch (line 100) | def fetch(self):
    method read_data (line 121) | def read_data(self, sample_count):
    method read_data_nvmem (line 148) | def read_data_nvmem(self):
    method read_last_data (line 161) | def read_last_data(self):
    method read_meter (line 186) | def read_meter(self):

FILE: src/instruments/aimtti/aimttiel302p.py
  class AimTTiEL302P (line 21) | class AimTTiEL302P(PowerSupply, PowerSupply.Channel):
    class Mode (line 43) | class Mode(Enum):
    class Error (line 53) | class Error(Enum):
    method output (line 124) | def output(self):
    method output (line 128) | def output(self, newval):
    method name (line 151) | def name(self):
    method reset (line 161) | def reset(self):
    method channel (line 169) | def channel(self):

FILE: src/instruments/comet/cito_plus_1310.py
  class CitoPlus1310 (line 16) | class CitoPlus1310(Instrument):
    class RegulationMode (line 42) | class RegulationMode(IntEnum):
    method __init__ (line 49) | def __init__(self, filelike):
    method name (line 71) | def name(self) -> str:
    method forward_power (line 77) | def forward_power(self) -> u.Quantity:
    method load_power (line 88) | def load_power(self) -> u.Quantity:
    method output_power (line 99) | def output_power(self) -> u.Quantity:
    method output_power (line 110) | def output_power(self, value: u.Quantity) -> None:
    method reflected_power (line 118) | def reflected_power(self) -> u.Quantity:
    method regulation_mode (line 129) | def regulation_mode(self) -> RegulationMode:
    method regulation_mode (line 139) | def regulation_mode(self, value) -> None:
    method rf (line 143) | def rf(self) -> bool:
    method rf (line 153) | def rf(self, value: bool) -> None:
    method sendcmd (line 157) | def sendcmd(self, pkg: bytes) -> None:
    method query (line 167) | def query(self, pkg: bytes, write_cmd=False) -> Union[None, bytes]:
    method _check_exception (line 211) | def _check_exception(self, fn_code: int, exc_code: int) -> None:
    method _make_hdr (line 224) | def _make_hdr(self, fn_code: int) -> bytes:
    method _make_pkg (line 235) | def _make_pkg(self, cmd_code, data=None, data_length=4):
  function _crc16 (line 266) | def _crc16(data: bytes):

FILE: src/instruments/config.py
  function walk_dict (line 19) | def walk_dict(d, path):
  function quantity_constructor (line 48) | def quantity_constructor(loader, node):
  function load_instruments (line 64) | def load_instruments(conf_file_name, conf_path="/"):

FILE: src/instruments/delta_elektronika/psc_eth.py
  class PscEth (line 15) | class PscEth(Instrument):
    method __init__ (line 28) | def __init__(self, filelike):
    class LimitStatus (line 31) | class LimitStatus(IntEnum):
    method name (line 40) | def name(self) -> str:
    method current_limit (line 44) | def current_limit(self) -> tuple["PscEth.LimitStatus", u.Quantity]:
    method voltage_limit (line 56) | def voltage_limit(self) -> tuple["PscEth.LimitStatus", u.Quantity]:
    method recall (line 175) | def recall(self) -> None:
    method reset (line 179) | def reset(self) -> None:
    method save (line 183) | def save(self) -> None:
    method set_current_limit (line 187) | def set_current_limit(
    method set_voltage_limit (line 203) | def set_voltage_limit(

FILE: src/instruments/dressler/cesar_1312.py
  class Cesar1312 (line 15) | class Cesar1312(Instrument):
    class ControlMode (line 39) | class ControlMode(IntEnum):
    class RegulationMode (line 46) | class RegulationMode(IntEnum):
    method __init__ (line 53) | def __init__(self, filelike):
    method address (line 78) | def address(self) -> int:
    method address (line 90) | def address(self, value: int) -> None:
    method retries (line 96) | def retries(self) -> int:
    method retries (line 105) | def retries(self, value: int) -> tuple[int, int, bytes]:
    method control_mode (line 113) | def control_mode(self) -> ControlMode:
    method control_mode (line 134) | def control_mode(self, value: ControlMode) -> None:
    method name (line 138) | def name(self) -> str:
    method output_power (line 153) | def output_power(self) -> u.Quantity:
    method output_power (line 168) | def output_power(self, value: u.Quantity) -> None:
    method reflected_power (line 174) | def reflected_power(self) -> u.Quantity:
    method regulation_mode (line 188) | def regulation_mode(self) -> RegulationMode:
    method regulation_mode (line 205) | def regulation_mode(self, value: RegulationMode) -> None:
    method rf (line 209) | def rf(self) -> bool:
    method rf (line 226) | def rf(self, value: bool) -> None:
    method query (line 232) | def query(self, package: bytes, len_data=1) -> bytes:
    method sendcmd (line 301) | def sendcmd(self, pkg: bytes) -> None:
    method _make_data (line 319) | def _make_data(
    method _make_pkg (line 344) | def _make_pkg(self, cmd_number: int, data: Union[None, bytes] = None) ...
    method _calculate_checksum (line 374) | def _calculate_checksum(data: bytes) -> bytes:
    method _pack_header (line 388) | def _pack_header(self, data_length: int):
    method _unpack_header (line 400) | def _unpack_header(hdr: bytes) -> tuple[int]:

FILE: src/instruments/errors.py
  class AcknowledgementError (line 12) | class AcknowledgementError(IOError):
  class PromptError (line 19) | class PromptError(IOError):

FILE: src/instruments/fluke/fluke3000.py
  class Fluke3000 (line 44) | class Fluke3000(Multimeter):
    method __init__ (line 96) | def __init__(self, filelike):
    class Module (line 108) | class Module(Enum):
    class Mode (line 118) | class Mode(Enum):
    method mode (line 143) | def mode(self):
    method trigger_mode (line 163) | def trigger_mode(self):
    method relative (line 179) | def relative(self):
    method input_range (line 192) | def input_range(self):
    method connect (line 204) | def connect(self):
    method scan (line 223) | def scan(self):
    method reset (line 249) | def reset(self):
    method read_lines (line 256) | def read_lines(self, nlines=1):
    method query_lines (line 272) | def query_lines(self, cmd, nlines=1):
    method flush (line 290) | def flush(self):
    method measure (line 308) | def measure(self, mode):
    method _get_module (line 360) | def _get_module(self, mode):
    method _parse (line 376) | def _parse(self, result, mode):
    method _parse_mode (line 416) | def _parse_mode(data):
    method _parse_value (line 431) | def _parse_value(data):
    method _parse_factor (line 446) | def _parse_factor(data):

FILE: src/instruments/generic_scpi/scpi_function_generator.py
  class SCPIFunctionGenerator (line 18) | class SCPIFunctionGenerator(FunctionGenerator, SCPIInstrument):
    method _get_amplitude_ (line 43) | def _get_amplitude_(self):
    method _set_amplitude_ (line 55) | def _set_amplitude_(self, magnitude, units):
    method phase (line 105) | def phase(self):
    method phase (line 109) | def phase(self, newval):

FILE: src/instruments/generic_scpi/scpi_instrument.py
  class SCPIInstrument (line 17) | class SCPIInstrument(Instrument):
    method name (line 36) | def name(self):
    method scpi_version (line 46) | def scpi_version(self):
    method op_complete (line 55) | def op_complete(self):
    method power_on_status (line 65) | def power_on_status(self):
    method power_on_status (line 75) | def power_on_status(self, newval):
    method self_test_ok (line 88) | def self_test_ok(self):
    method reset (line 104) | def reset(self):
    method clear (line 111) | def clear(self):
    method trigger (line 118) | def trigger(self):
    method wait_to_continue (line 129) | def wait_to_continue(self):
    method line_frequency (line 139) | def line_frequency(self):
    method line_frequency (line 150) | def line_frequency(self, newval):
    class ErrorCodes (line 162) | class ErrorCodes(IntEnum):
    method check_error_queue (line 235) | def check_error_queue(self):
    method display_brightness (line 256) | def display_brightness(self):
    method display_brightness (line 266) | def display_brightness(self, newval):
    method display_contrast (line 272) | def display_contrast(self):
    method display_contrast (line 282) | def display_contrast(self, newval):

FILE: src/instruments/generic_scpi/scpi_multimeter.py
  class SCPIMultimeter (line 32) | class SCPIMultimeter(SCPIInstrument, Multimeter):
    class Mode (line 46) | class Mode(Enum):
    class TriggerMode (line 64) | class TriggerMode(Enum):
    class InputRange (line 82) | class InputRange(Enum):
    class Resolution (line 92) | class Resolution(Enum):
    class TriggerCount (line 102) | class TriggerCount(Enum):
    class SampleCount (line 112) | class SampleCount(Enum):
    class SampleSource (line 121) | class SampleSource(Enum):
    method input_range (line 170) | def input_range(self):
    method input_range (line 192) | def input_range(self, newval):
    method resolution (line 203) | def resolution(self):
    method resolution (line 224) | def resolution(self, newval):
    method trigger_count (line 238) | def trigger_count(self):
    method trigger_count (line 269) | def trigger_count(self, newval):
    method sample_count (line 280) | def sample_count(self):
    method sample_count (line 312) | def sample_count(self, newval):
    method relative (line 367) | def relative(self):
    method relative (line 371) | def relative(self, newval):
    method measure (line 376) | def measure(self, mode=None):
    method _mode_parse (line 405) | def _mode_parse(val):

FILE: src/instruments/gentec_eo/blu.py
  class Blu (line 15) | class Blu(Instrument):
    method __init__ (line 41) | def __init__(self, filelike):
    method _ack_expected (line 53) | def _ack_expected(self, msg=""):
    class Scale (line 59) | class Scale(Enum):
    method anticipation (line 117) | def anticipation(self):
    method anticipation (line 138) | def anticipation(self, newval):
    method auto_scale (line 143) | def auto_scale(self):
    method auto_scale (line 163) | def auto_scale(self, newval):
    method available_scales (line 168) | def available_scales(self):
    method battery_state (line 205) | def battery_state(self):
    method current_value (line 222) | def current_value(self):
    method head_type (line 242) | def head_type(self):
    method measure_mode (line 257) | def measure_mode(self):
    method new_value_ready (line 282) | def new_value_ready(self):
    method scale (line 302) | def scale(self):
    method scale (line 330) | def scale(self, newval):
    method single_shot_energy_mode (line 334) | def single_shot_energy_mode(self):
    method single_shot_energy_mode (line 352) | def single_shot_energy_mode(self, newval):
    method trigger_level (line 358) | def trigger_level(self):
    method trigger_level (line 383) | def trigger_level(self, newval):
    method usb_state (line 399) | def usb_state(self):
    method user_multiplier (line 414) | def user_multiplier(self):
    method user_multiplier (line 430) | def user_multiplier(self, newval):
    method user_offset (line 435) | def user_offset(self):
    method user_offset (line 464) | def user_offset(self, newval):
    method version (line 479) | def version(self):
    method wavelength (line 494) | def wavelength(self):
    method wavelength (line 516) | def wavelength(self, newval):
    method zero_offset (line 524) | def zero_offset(self):
    method zero_offset (line 546) | def zero_offset(self, newval):
    method confirm_connection (line 554) | def confirm_connection(self):
    method disconnect (line 566) | def disconnect(self):
    method scale_down (line 576) | def scale_down(self):
    method scale_up (line 589) | def scale_up(self):
    method _no_ack_query (line 604) | def _no_ack_query(self, cmd, size=-1):
    method _value_query (line 613) | def _value_query(self, cmd, tp=str):
  function _format_eight (line 636) | def _format_eight(value):

FILE: src/instruments/glassman/glassmanfr.py
  class GlassmanFR (line 45) | class GlassmanFR(PowerSupply, PowerSupply.Channel):
    method __init__ (line 81) | def __init__(self, filelike):
    class Mode (line 96) | class Mode(Enum):
    class ResponseCode (line 106) | class ResponseCode(Enum):
    class ErrorCode (line 120) | class ErrorCode(Enum):
    method channel (line 141) | def channel(self):
    method voltage (line 152) | def voltage(self):
    method voltage (line 162) | def voltage(self, newval):
    method current (line 166) | def current(self):
    method current (line 176) | def current(self, newval):
    method voltage_sense (line 180) | def voltage_sense(self):
    method current_sense (line 190) | def current_sense(self):
    method mode (line 200) | def mode(self):
    method output (line 216) | def output(self):
    method output (line 228) | def output(self, newval):
    method fault (line 234) | def fault(self):
    method version (line 245) | def version(self):
    method device_timeout (line 255) | def device_timeout(self):
    method device_timeout (line 267) | def device_timeout(self, newval):
    method sendcmd (line 275) | def sendcmd(self, cmd):
    method query (line 286) | def query(self, cmd, size=-1):
    method reset (line 316) | def reset(self):
    method set_status (line 322) | def set_status(self, voltage=None, current=None, output=None, reset=Fa...
    method get_status (line 366) | def get_status(self):
    method _parse_response (line 377) | def _parse_response(self, response):
    method _parse_voltage (line 406) | def _parse_voltage(self, word):
    method _parse_current (line 420) | def _parse_current(self, word):
    method _parse_monitors (line 434) | def _parse_monitors(self, word):
    method _verify_checksum (line 450) | def _verify_checksum(self, word):
    method _get_checksum (line 468) | def _get_checksum(data):

FILE: src/instruments/hcp/tc038.py
  class TC038 (line 17) | class TC038(Instrument):
    method __init__ (line 32) | def __init__(self, *args, **kwargs):
    method sendcmd (line 50) | def sendcmd(self, command):
    method query (line 63) | def query(self, command):
    method monitored_quantity (line 81) | def monitored_quantity(self):
    method monitored_quantity (line 86) | def monitored_quantity(self, quantity="temperature"):
    method setpoint (line 102) | def setpoint(self):
    method setpoint (line 111) | def setpoint(self, value):
    method temperature (line 120) | def temperature(self):
    method monitored_value (line 126) | def monitored_value(self):
    method information (line 137) | def information(self):
    method _data_to_temp (line 142) | def _data_to_temp(data):

FILE: src/instruments/hcp/tc038d.py
  class TC038D (line 17) | class TC038D(Instrument):
    method __init__ (line 34) | def __init__(self, *args, **kwargs):
    method CRC16 (line 50) | def CRC16(data):
    method readRegister (line 62) | def readRegister(self, address, count=1):
    method writeMultiple (line 89) | def writeMultiple(self, address, values):
    method setpoint (line 130) | def setpoint(self):
    method setpoint (line 136) | def setpoint(self, value):
    method temperature (line 143) | def temperature(self):

FILE: src/instruments/holzworth/holzworth_hs9000.py
  class HS9000 (line 22) | class HS9000(SignalGenerator):
    class Channel (line 32) | class Channel(SGChannel):
      method __init__ (line 40) | def __init__(self, hs, idx_chan):
      method sendcmd (line 55) | def sendcmd(self, cmd):
      method query (line 65) | def query(self, cmd):
      method reset (line 79) | def reset(self):
      method recall_state (line 90) | def recall_state(self):
      method save_state (line 101) | def save_state(self):
      method temperature (line 115) | def temperature(self):
    method _channel_idxs (line 206) | def _channel_idxs(self):
    method channel (line 229) | def channel(self):
    method name (line 248) | def name(self):
    method ready (line 262) | def ready(self):

FILE: src/instruments/hp/hp3325a.py
  function amplitude_parse (line 44) | def amplitude_parse(am_resp: str) -> float:
  function frequency_parse (line 50) | def frequency_parse(fr_resp: str) -> float:
  function offset_parse (line 56) | def offset_parse(of_resp: str) -> float:
  class HP3325a (line 62) | class HP3325a(FunctionGenerator):
    method __init__ (line 71) | def __init__(self, filelike):
    class Waveform (line 80) | class Waveform(IntEnum):
    class FrequencyScale (line 92) | class FrequencyScale(Enum):
    class AmplitudeScale (line 101) | class AmplitudeScale(Enum):
    method query (line 229) | def query(self, cmd, size=-1):
    method amplitude_calibration (line 237) | def amplitude_calibration(self):
    method assign_zero_phase (line 240) | def assign_zero_phase(self):
    method query_error (line 256) | def query_error(self) -> int:

FILE: src/instruments/hp/hp3456a.py
  class HP3456a (line 44) | class HP3456a(Multimeter):
    method __init__ (line 57) | def __init__(self, filelike):
    class MathMode (line 70) | class MathMode(IntEnum):
    class Mode (line 86) | class Mode(Enum):
    class Register (line 112) | class Register(Enum):
    class TriggerMode (line 130) | class TriggerMode(IntEnum):
    class ValidRange (line 140) | class ValidRange(Enum):
    method number_of_readings (line 232) | def number_of_readings(self):
    method number_of_readings (line 243) | def number_of_readings(self, value):
    method number_of_digits (line 247) | def number_of_digits(self):
    method number_of_digits (line 259) | def number_of_digits(self, newval):
    method nplc (line 269) | def nplc(self):
    method nplc (line 282) | def nplc(self, newval):
    method delay (line 291) | def delay(self):
    method delay (line 302) | def delay(self, value):
    method mean (line 307) | def mean(self):
    method variance (line 317) | def variance(self):
    method count (line 327) | def count(self):
    method lower (line 337) | def lower(self):
    method lower (line 348) | def lower(self, value):
    method upper (line 352) | def upper(self):
    method upper (line 364) | def upper(self, value):
    method r (line 368) | def r(self):
    method r (line 380) | def r(self, value):
    method y (line 384) | def y(self):
    method y (line 395) | def y(self, value):
    method z (line 399) | def z(self):
    method z (line 411) | def z(self, value):
    method input_range (line 415) | def input_range(self):
    method input_range (line 427) | def input_range(self, value):
    method relative (line 463) | def relative(self):
    method relative (line 472) | def relative(self, value):
    method auto_range (line 487) | def auto_range(self):
    method fetch (line 495) | def fetch(self, mode=None):
    method measure (line 533) | def measure(self, mode=None):
    method _register_read (line 571) | def _register_read(self, name):
    method _register_write (line 593) | def _register_write(self, name, value):
    method trigger (line 620) | def trigger(self):

FILE: src/instruments/hp/hp6624a.py
  class HP6624a (line 17) | class HP6624a(PowerSupply):
    method __init__ (line 33) | def __init__(self, filelike):
    class Channel (line 39) | class Channel(PowerSupply.Channel):
      method __init__ (line 47) | def __init__(self, hp, idx):
      method _format_cmd (line 53) | def _format_cmd(self, cmd):
      method sendcmd (line 63) | def sendcmd(self, cmd):
      method query (line 74) | def query(self, cmd):
      method mode (line 90) | def mode(self):
      method mode (line 97) | def mode(self, newval):
      method reset (line 202) | def reset(self):
    class Mode (line 211) | class Mode(Enum):
    method channel (line 226) | def channel(self):
    method voltage (line 239) | def voltage(self):
    method voltage (line 250) | def voltage(self, newval):
    method current (line 265) | def current(self):
    method current (line 276) | def current(self, newval):
    method voltage_sense (line 291) | def voltage_sense(self):
    method current_sense (line 301) | def current_sense(self):
    method channel_count (line 311) | def channel_count(self):
    method channel_count (line 321) | def channel_count(self, newval):
    method clear (line 330) | def clear(self):

FILE: src/instruments/hp/hp6632b.py
  class HP6632b (line 50) | class HP6632b(SCPIInstrument, HP6652a):
    class ALCBandwidth (line 81) | class ALCBandwidth(IntEnum):
    class DigitalFunction (line 89) | class DigitalFunction(Enum):
    class DFISource (line 97) | class DFISource(Enum):
    class ErrorCodes (line 108) | class ErrorCodes(IntEnum):
    class RemoteInhibit (line 232) | class RemoteInhibit(Enum):
    class SenseWindow (line 241) | class SenseWindow(Enum):
    method init_output_trigger (line 423) | def init_output_trigger(self):
    method abort_output_trigger (line 430) | def abort_output_trigger(self):
    method line_frequency (line 439) | def line_frequency(self):
    method line_frequency (line 443) | def line_frequency(self, newval):
    method display_brightness (line 447) | def display_brightness(self):
    method display_brightness (line 451) | def display_brightness(self, newval):
    method display_contrast (line 455) | def display_contrast(self):
    method display_contrast (line 459) | def display_contrast(self, newval):
    method check_error_queue (line 462) | def check_error_queue(self):

FILE: src/instruments/hp/hp6652a.py
  class HP6652a (line 19) | class HP6652a(PowerSupply, PowerSupply.Channel):
    method name (line 168) | def name(self):
    method mode (line 180) | def mode(self):
    method mode (line 187) | def mode(self, newval):
    method reset (line 195) | def reset(self):
    method display_text (line 201) | def display_text(self, text_to_display):
    method channel (line 240) | def channel(self):

FILE: src/instruments/hp/hpe3631a.py
  class HPe3631a (line 53) | class HPe3631a(PowerSupply, PowerSupply.Channel, SCPIInstrument):
    method __init__ (line 82) | def __init__(self, filelike):
    class Channel (line 89) | class Channel:
      method __init__ (line 97) | def __init__(self, parent, valid_set):
      method __getitem__ (line 101) | def __getitem__(self, idx):
      method __len__ (line 109) | def __len__(self):
    method channel (line 115) | def channel(self):
    method mode (line 128) | def mode(self):
    method voltage (line 152) | def voltage(self):
    method voltage (line 163) | def voltage(self, newval):
    method voltage_min (line 189) | def voltage_min(self):
    method voltage_max (line 199) | def voltage_max(self):
    method voltage_range (line 209) | def voltage_range(self):

FILE: src/instruments/keithley/keithley195.py
  class Keithley195 (line 19) | class Keithley195(Multimeter):
    method __init__ (line 34) | def __init__(self, filelike):
    class Mode (line 41) | class Mode(IntEnum):
    class TriggerMode (line 52) | class TriggerMode(IntEnum):
    class ValidRange (line 66) | class ValidRange(Enum):
    method mode (line 80) | def mode(self):
    method mode (line 98) | def mode(self, newval):
    method trigger_mode (line 109) | def trigger_mode(self):
    method trigger_mode (line 136) | def trigger_mode(self, newval):
    method relative (line 148) | def relative(self):
    method relative (line 170) | def relative(self, newval):
    method input_range (line 176) | def input_range(self):
    method input_range (line 207) | def input_range(self, newval):
    method measure (line 238) | def measure(self, mode=None):
    method get_status_word (line 277) | def get_status_word(self):
    method parse_status_word (line 292) | def parse_status_word(statusword):  # pylint: disable=too-many-locals
    method trigger (line 349) | def trigger(self):
    method auto_range (line 358) | def auto_range(self):

FILE: src/instruments/keithley/keithley2182.py
  class Keithley2182 (line 19) | class Keithley2182(SCPIMultimeter):
    class Channel (line 35) | class Channel(Multimeter):
      method __init__ (line 44) | def __init__(self, parent, idx):
      method mode (line 51) | def mode(self):
      method mode (line 55) | def mode(self, newval):
      method trigger_mode (line 59) | def trigger_mode(self):
      method trigger_mode (line 63) | def trigger_mode(self, newval):
      method relative (line 67) | def relative(self):
      method relative (line 71) | def relative(self, newval):
      method input_range (line 75) | def input_range(self):
      method input_range (line 79) | def input_range(self, newval):
      method measure (line 84) | def measure(self, mode=None):
    class Mode (line 104) | class Mode(Enum):
    class TriggerMode (line 112) | class TriggerMode(Enum):
    method channel (line 126) | def channel(self):
    method relative (line 143) | def relative(self):
    method relative (line 162) | def relative(self, newval):
    method input_range (line 173) | def input_range(self):
    method input_range (line 177) | def input_range(self, newval):
    method units (line 181) | def units(self):
    method fetch (line 203) | def fetch(self):
    method measure (line 224) | def measure(self, mode=None):

FILE: src/instruments/keithley/keithley485.py
  class Keithley485 (line 44) | class Keithley485(Instrument):
    class TriggerMode (line 63) | class TriggerMode(Enum):
    class SRQDataMask (line 81) | class SRQDataMask(Enum):
    class SRQErrorMask (line 103) | class SRQErrorMask(Enum):
    class Status (line 125) | class Status(Enum):
    method zero_check (line 142) | def zero_check(self):
    method zero_check (line 156) | def zero_check(self, newval):
    method log (line 162) | def log(self):
    method log (line 176) | def log(self, newval):
    method input_range (line 182) | def input_range(self):
    method input_range (line 195) | def input_range(self, newval):
    method relative (line 223) | def relative(self):
    method relative (line 245) | def relative(self, newval):
    method eoi_mode (line 251) | def eoi_mode(self):
    method eoi_mode (line 267) | def eoi_mode(self, newval):
    method trigger_mode (line 273) | def trigger_mode(self):
    method trigger_mode (line 298) | def trigger_mode(self, newval):
    method auto_range (line 311) | def auto_range(self):
    method get_status (line 320) | def get_status(self):
    method _get_status_word (line 332) | def _get_status_word(self):
    method _parse_status_word (line 350) | def _parse_status_word(self, statusword):
    method measure (line 411) | def measure(self):
    method _parse_measurement (line 419) | def _parse_measurement(self, measurement):

FILE: src/instruments/keithley/keithley580.py
  class Keithley580 (line 47) | class Keithley580(Instrument):
    method __init__ (line 57) | def __init__(self, filelike):
    class Polarity (line 66) | class Polarity(IntEnum):
    class Drive (line 74) | class Drive(IntEnum):
    class TriggerMode (line 82) | class TriggerMode(IntEnum):
    method polarity (line 97) | def polarity(self):
    method polarity (line 116) | def polarity(self, newval):
    method drive (line 129) | def drive(self):
    method drive (line 145) | def drive(self, newval):
    method dry_circuit_test (line 158) | def dry_circuit_test(self):
    method dry_circuit_test (line 175) | def dry_circuit_test(self, newval):
    method operate (line 181) | def operate(self):
    method operate (line 192) | def operate(self, newval):
    method relative (line 198) | def relative(self):
    method relative (line 220) | def relative(self, newval):
    method trigger_mode (line 226) | def trigger_mode(self):
    method trigger_mode (line 250) | def trigger_mode(self, newval):
    method input_range (line 262) | def input_range(self):
    method input_range (line 276) | def input_range(self, newval):
    method trigger (line 305) | def trigger(self):
    method auto_range (line 314) | def auto_range(self):
    method set_calibration_value (line 323) | def set_calibration_value(self, value):
    method store_calibration_constants (line 332) | def store_calibration_constants(self):
    method get_status_word (line 340) | def get_status_word(self):
    method parse_status_word (line 362) | def parse_status_word(self, statusword):
    method measure (line 434) | def measure(self):
    method parse_measurement (line 448) | def parse_measurement(measurement):
    method sendcmd (line 494) | def sendcmd(self, cmd):
    method query (line 497) | def query(self, cmd, size=-1):

FILE: src/instruments/keithley/keithley6220.py
  class Keithley6220 (line 18) | class Keithley6220(SCPIInstrument, PowerSupply):
    method channel (line 37) | def channel(self):
    method voltage (line 53) | def voltage(self):
    method voltage (line 62) | def voltage(self, newval):
    method disable (line 82) | def disable(self):

FILE: src/instruments/keithley/keithley6514.py
  class Keithley6514 (line 18) | class Keithley6514(SCPIInstrument, Electrometer):
    class Mode (line 32) | class Mode(Enum):
    class TriggerMode (line 42) | class TriggerMode(Enum):
    class ArmSource (line 50) | class ArmSource(Enum):
    class ValidRange (line 64) | class ValidRange(Enum):
    method _valid_range (line 96) | def _valid_range(self, mode):
    method _parse_measurement (line 108) | def _parse_measurement(self, ascii):
    method unit (line 165) | def unit(self):
    method auto_range (line 169) | def auto_range(self):
    method auto_range (line 180) | def auto_range(self, newval):
    method input_range (line 185) | def input_range(self):
    method input_range (line 197) | def input_range(self, newval):
    method auto_config (line 207) | def auto_config(self, mode):
    method fetch (line 222) | def fetch(self):
    method read_measurements (line 232) | def read_measurements(self):

FILE: src/instruments/lakeshore/lakeshore336.py
  class Lakeshore336 (line 15) | class Lakeshore336(SCPIInstrument):
    class Sensor (line 31) | class Sensor:
      method __init__ (line 39) | def __init__(self, parent, idx):
      method temperature (line 47) | def temperature(self):
    method sensor (line 60) | def sensor(self):

FILE: src/instruments/lakeshore/lakeshore340.py
  class Lakeshore340 (line 15) | class Lakeshore340(SCPIInstrument):
    class Sensor (line 30) | class Sensor:
      method __init__ (line 38) | def __init__(self, parent, idx):
      method temperature (line 45) | def temperature(self):
    method sensor (line 58) | def sensor(self):

FILE: src/instruments/lakeshore/lakeshore370.py
  class Lakeshore370 (line 15) | class Lakeshore370(SCPIInstrument):
    method __init__ (line 27) | def __init__(self, filelike):
    class Channel (line 34) | class Channel:
      method __init__ (line 42) | def __init__(self, parent, idx):
      method resistance (line 49) | def resistance(self):
    method channel (line 62) | def channel(self):

FILE: src/instruments/lakeshore/lakeshore475.py
  class Lakeshore475 (line 26) | class Lakeshore475(SCPIInstrument):
    class Mode (line 42) | class Mode(IntEnum):
    class Filter (line 51) | class Filter(IntEnum):
    class PeakMode (line 60) | class PeakMode(IntEnum):
    class PeakDisplay (line 68) | class PeakDisplay(IntEnum):
    method field (line 80) | def field(self):
    method field_units (line 89) | def field_units(self):
    method field_units (line 101) | def field_units(self, newval):
    method temp_units (line 111) | def temp_units(self):
    method temp_units (line 123) | def temp_units(self, newval):
    method field_setpoint (line 133) | def field_setpoint(self):
    method field_setpoint (line 146) | def field_setpoint(self, newval):
    method field_control_params (line 160) | def field_control_params(self):
    method field_control_params (line 174) | def field_control_params(self, newval):
    method p_value (line 198) | def p_value(self):
    method p_value (line 207) | def p_value(self, newval):
    method i_value (line 214) | def i_value(self):
    method i_value (line 223) | def i_value(self, newval):
    method ramp_rate (line 230) | def ramp_rate(self):
    method ramp_rate (line 241) | def ramp_rate(self, newval):
    method control_slope_limit (line 249) | def control_slope_limit(self):
    method control_slope_limit (line 260) | def control_slope_limit(self, newval):
    method change_measurement_mode (line 283) | def change_measurement_mode(

FILE: src/instruments/mettler_toledo/mt_sics.py
  class MTSICS (line 14) | class MTSICS(Instrument):
    class WeightMode (line 27) | class WeightMode(Enum):
    method __init__ (line 35) | def __init__(self, filelike, *args, **kwargs):
    method clear_tare (line 40) | def clear_tare(self):
    method reset (line 52) | def reset(self):
    method tare (line 64) | def tare(self, immediately=None):
    method zero (line 85) | def zero(self, immediately=None):
    method query (line 110) | def query(self, cmd, size=-1):
    method _cmd_error_checking (line 139) | def _cmd_error_checking(self, value):
    method _general_error_checking (line 163) | def _general_error_checking(self, value):
    method mt_sics (line 181) | def mt_sics(self):
    method mt_sics_commands (line 199) | def mt_sics_commands(self):
    method name (line 234) | def name(self):
    method name (line 253) | def name(self, value):
    method serial_number (line 259) | def serial_number(self):
    method tare_value (line 276) | def tare_value(self):
    method tare_value (line 293) | def tare_value(self, value):
    method weight (line 299) | def weight(self):
    method weight_mode (line 321) | def weight_mode(self):
    method weight_mode (line 342) | def weight_mode(self, value):

FILE: src/instruments/minghe/mhs5200a.py
  class MHS5200 (line 19) | class MHS5200(FunctionGenerator):
    method __init__ (line 28) | def __init__(self, filelike):
    method _ack_expected (line 33) | def _ack_expected(self, msg=""):
    class Channel (line 41) | class Channel(FunctionGenerator.Channel):
      method __init__ (line 50) | def __init__(self, mhs, idx):
      method _get_amplitude_ (line 59) | def _get_amplitude_(self):
      method _set_amplitude_ (line 64) | def _set_amplitude_(self, magnitude, units):
      method duty_cycle (line 77) | def duty_cycle(self):
      method duty_cycle (line 90) | def duty_cycle(self, new_val):
      method enable (line 95) | def enable(self):
      method enable (line 105) | def enable(self, newval):
      method frequency (line 110) | def frequency(self):
      method frequency (line 124) | def frequency(self, new_val):
      method offset (line 130) | def offset(self):
      method offset (line 144) | def offset(self, new_val):
      method phase (line 150) | def phase(self):
      method phase (line 164) | def phase(self, new_val):
      method function (line 170) | def function(self):
      method function (line 181) | def function(self, new_val):
    class Function (line 185) | class Function(Enum):
    method channel (line 197) | def channel(self):
    method serial_number (line 214) | def serial_number(self):
    method _get_amplitude_ (line 225) | def _get_amplitude_(self):
    method _set_amplitude_ (line 228) | def _set_amplitude_(self, magnitude, units):

FILE: src/instruments/named_struct.py
  class Field (line 34) | class Field:
    method __init__ (line 49) | def __init__(self, fmt, strip_null=False):
    method is_significant (line 64) | def is_significant(self):
    method fmt_char (line 68) | def fmt_char(self):
    method __len__ (line 74) | def __len__(self):
    method __repr__ (line 82) | def __repr__(self):
    method __str__ (line 90) | def __str__(self):
    method __get__ (line 120) | def __get__(self, obj, type=None):
    method __set__ (line 123) | def __set__(self, obj, value):
  class StringField (line 127) | class StringField(Field):
    method __init__ (line 144) | def __init__(self, length, encoding="ascii", strip_null=False):
    method __set__ (line 149) | def __set__(self, obj, value):
    method __get__ (line 158) | def __get__(self, obj, type=None):
  class Padding (line 162) | class Padding(Field):
    method __init__ (line 170) | def __init__(self, n_bytes=1):
  class HasFields (line 174) | class HasFields(type):
    method __new__ (line 179) | def __new__(mcs, name, bases, attrs):
  class NamedStruct (line 219) | class NamedStruct(metaclass=HasFields):
    method __init__ (line 248) | def __init__(self, **kwargs):
    method _to_seq (line 260) | def _to_seq(self):
    method _from_seq (line 264) | def _from_seq(cls, new_values):
    method pack (line 274) | def pack(self):
    method unpack (line 285) | def unpack(cls, buffer):
    method __eq__ (line 295) | def __eq__(self, other):
    method __hash__ (line 301) | def __hash__(self):
    method __str__ (line 304) | def __str__(self):

FILE: src/instruments/newport/agilis.py
  class AGUC2 (line 41) | class AGUC2(Instrument):
    method __init__ (line 85) | def __init__(self, filelike):
    class Axis (line 95) | class Axis:
      method __init__ (line 104) | def __init__(self, cont, ax):
      method axis_status (line 120) | def axis_status(self):
      method jog (line 133) | def jog(self):
      method jog (line 157) | def jog(self, mode):
      method number_of_steps (line 165) | def number_of_steps(self):
      method move_relative (line 188) | def move_relative(self):
      method move_relative (line 200) | def move_relative(self, steps):
      method move_to_limit (line 211) | def move_to_limit(self):
      method move_to_limit (line 229) | def move_to_limit(self, mode):
      method step_amplitude (line 237) | def step_amplitude(self):
      method step_amplitude (line 258) | def step_amplitude(self, nns):
      method step_delay (line 276) | def step_delay(self):
      method step_delay (line 293) | def step_delay(self, nn):
      method am_i_still (line 304) | def am_i_still(self, max_retries=5):
      method stop (line 339) | def stop(self):
      method zero_position (line 345) | def zero_position(self):
    class Axes (line 353) | class Axes(IntEnum):
    method axis (line 366) | def axis(self):
    method enable_remote_mode (line 385) | def enable_remote_mode(self):
    method enable_remote_mode (line 392) | def enable_remote_mode(self, newval):
    method error_previous_command (line 401) | def error_previous_command(self):
    method firmware_version (line 416) | def firmware_version(self):
    method limit_status (line 424) | def limit_status(self):
    method sleep_time (line 445) | def sleep_time(self):
    method sleep_time (line 456) | def sleep_time(self, t):
    method reset_controller (line 464) | def reset_controller(self):
    method ag_sendcmd (line 474) | def ag_sendcmd(self, cmd):
    method ag_query (line 481) | def ag_query(self, cmd, size=-1):
  function agilis_error_message (line 499) | def agilis_error_message(error_code):
  function agilis_status_message (line 527) | def agilis_status_message(status_code):

FILE: src/instruments/newport/errors.py
  class NewportError (line 14) | class NewportError(IOError):
    method __init__ (line 101) | def __init__(self, errcode=None, timestamp=None):
    method get_message (line 138) | def get_message(code):
    method timestamp (line 151) | def timestamp(self):
    method errcode (line 161) | def errcode(self):
    method axis (line 170) | def axis(self):

FILE: src/instruments/newport/newport_pmc8742.py
  class PicoMotorController8742 (line 45) | class PicoMotorController8742(Instrument):
    method __init__ (line 82) | def __init__(self, filelike):
    class Axis (line 94) | class Axis:
      method __init__ (line 97) | def __init__(self, parent, idx):
      class MotorType (line 127) | class MotorType(IntEnum):
      method acceleration (line 143) | def acceleration(self):
      method acceleration (line 167) | def acceleration(self, value):
      method home_position (line 177) | def home_position(self):
      method home_position (line 200) | def home_position(self, value):
      method is_stopped (line 209) | def is_stopped(self):
      method motor_type (line 227) | def motor_type(self):
      method motor_type (line 249) | def motor_type(self, value):
      method move_absolute (line 258) | def move_absolute(self):
      method move_absolute (line 281) | def move_absolute(self, value):
      method move_relative (line 290) | def move_relative(self):
      method move_relative (line 313) | def move_relative(self, value):
      method position (line 322) | def position(self):
      method velocity (line 342) | def velocity(self):
      method velocity (line 368) | def velocity(self, value):
      method move_indefinite (line 385) | def move_indefinite(self, direction):
      method stop (line 408) | def stop(self):
      method controller_address (line 427) | def controller_address(self):
      method controller_address (line 440) | def controller_address(self, newval):
      method controller_configuration (line 444) | def controller_configuration(self):
      method controller_configuration (line 472) | def controller_configuration(self, value):
      method error_code (line 479) | def error_code(self):
      method error_code_and_message (line 490) | def error_code_and_message(self):
      method firmware_version (line 503) | def firmware_version(self):
      method name (line 508) | def name(self):
      method abort_motion (line 514) | def abort_motion(self):
      method motor_check (line 518) | def motor_check(self):
      method purge (line 526) | def purge(self):
      method recall_parameters (line 543) | def recall_parameters(self, value=0):
      method reset (line 560) | def reset(self):
      method save_settings (line 571) | def save_settings(self):
      method sendcmd (line 596) | def sendcmd(self, cmd, axs=True):
      method query (line 611) | def query(self, cmd, size=-1, axs=True):
    method axis (line 642) | def axis(self):
    method controller_address (line 656) | def controller_address(self):
    method controller_address (line 676) | def controller_address(self, newval):
    method controller_configuration (line 680) | def controller_configuration(self):
    method controller_configuration (line 712) | def controller_configuration(self, value):
    method dhcp_mode (line 716) | def dhcp_mode(self):
    method dhcp_mode (line 736) | def dhcp_mode(self, newval):
    method error_code (line 741) | def error_code(self):
    method error_code_and_message (line 761) | def error_code_and_message(self):
    method firmware_version (line 779) | def firmware_version(self):
    method gateway (line 794) | def gateway(self):
    method gateway (line 811) | def gateway(self, value):
    method hostname (line 815) | def hostname(self):
    method hostname (line 832) | def hostname(self, value):
    method ip_address (line 836) | def ip_address(self):
    method ip_address (line 853) | def ip_address(self, value):
    method mac_address (line 857) | def mac_address(self):
    method multiple_controllers (line 875) | def multiple_controllers(self):
    method multiple_controllers (line 900) | def multiple_controllers(self, newval):
    method name (line 904) | def name(self):
    method netmask (line 919) | def netmask(self):
    method netmask (line 936) | def netmask(self, value):
    method scan_controllers (line 940) | def scan_controllers(self):
    method scan_done (line 975) | def scan_done(self):
    method abort_motion (line 994) | def abort_motion(self):
    method motor_check (line 1007) | def motor_check(self):
    method scan (line 1023) | def scan(self, value=2):
    method purge (line 1058) | def purge(self):
    method recall_parameters (line 1083) | def recall_parameters(self, value=0):
    method reset (line 1108) | def reset(self):
    method save_settings (line 1127) | def save_settings(self):
    method query (line 1160) | def query(self, cmd, size=-1):

FILE: src/instruments/newport/newportesp301.py
  class NewportESP301 (line 26) | class NewportESP301(Instrument):
    method __init__ (line 38) | def __init__(self, filelike):
    class Axis (line 45) | class Axis:
      method __init__ (line 77) | def __init__(self, controller, axis_id):
      method _units_of (line 91) | def _units_of(self, units):
      method _get_units (line 104) | def _get_units(self):
      method _set_units (line 115) | def _set_units(self, new_units):
      method axis_id (line 121) | def axis_id(self):
      method is_motion_done (line 130) | def is_motion_done(self):
      method acceleration (line 142) | def acceleration(self):
      method acceleration (line 157) | def acceleration(self, newval):
      method deceleration (line 168) | def deceleration(self):
      method deceleration (line 182) | def deceleration(self, newval):
      method estop_deceleration (line 193) | def estop_deceleration(self):
      method estop_deceleration (line 207) | def estop_deceleration(self, decel):
      method jerk (line 216) | def jerk(self):
      method jerk (line 231) | def jerk(self, jerk):
      method velocity (line 240) | def velocity(self):
      method velocity (line 253) | def velocity(self, velocity):
      method max_velocity (line 262) | def max_velocity(self):
      method max_velocity (line 275) | def max_velocity(self, newval):
      method max_base_velocity (line 284) | def max_base_velocity(self):
      method max_base_velocity (line 297) | def max_base_velocity(self, newval):
      method jog_high_velocity (line 306) | def jog_high_velocity(self):
      method jog_high_velocity (line 319) | def jog_high_velocity(self, newval):
      method jog_low_velocity (line 328) | def jog_low_velocity(self):
      method jog_low_velocity (line 341) | def jog_low_velocity(self, newval):
      method homing_velocity (line 350) | def homing_velocity(self):
      method homing_velocity (line 363) | def homing_velocity(self, newval):
      method max_acceleration (line 372) | def max_acceleration(self):
      method max_acceleration (line 386) | def max_acceleration(self, newval):
      method max_deceleration (line 397) | def max_deceleration(self):
      method max_deceleration (line 409) | def max_deceleration(self, decel):
      method position (line 418) | def position(self):
      method desired_position (line 431) | def desired_position(self):
      method desired_velocity (line 444) | def desired_velocity(self):
      method home (line 457) | def home(self):
      method home (line 471) | def home(self, newval):
      method units (line 478) | def units(self):
      method units (line 489) | def units(self, newval):
      method encoder_resolution (line 500) | def encoder_resolution(self):
      method encoder_resolution (line 514) | def encoder_resolution(self, newval):
      method full_step_resolution (line 521) | def full_step_resolution(self):
      method full_step_resolution (line 535) | def full_step_resolution(self, newval):
      method left_limit (line 542) | def left_limit(self):
      method left_limit (line 554) | def left_limit(self, limit):
      method right_limit (line 559) | def right_limit(self):
      method right_limit (line 571) | def right_limit(self, limit):
      method error_threshold (line 576) | def error_threshold(self):
      method error_threshold (line 588) | def error_threshold(self, newval):
      method current (line 595) | def current(self):
      method current (line 608) | def current(self, newval):
      method voltage (line 615) | def voltage(self):
      method voltage (line 628) | def voltage(self, newval):
      method motor_type (line 635) | def motor_type(self):
      method motor_type (line 652) | def motor_type(self, newval):
      method feedback_configuration (line 658) | def feedback_configuration(self):
      method feedback_configuration (line 667) | def feedback_configuration(self, newval):
      method position_display_resolution (line 673) | def position_display_resolution(self):
      method position_display_resolution (line 682) | def position_display_resolution(self, newval):
      method trajectory (line 688) | def trajectory(self):
      method trajectory (line 697) | def trajectory(self, newval):
      method microstep_factor (line 703) | def microstep_factor(self):
      method microstep_factor (line 712) | def microstep_factor(self, newval):
      method hardware_limit_configuration (line 722) | def hardware_limit_configuration(self):
      method hardware_limit_configuration (line 731) | def hardware_limit_configuration(self, newval):
      method acceleration_feed_forward (line 737) | def acceleration_feed_forward(self):
      method acceleration_feed_forward (line 746) | def acceleration_feed_forward(self, newval):
      method proportional_gain (line 752) | def proportional_gain(self):
      method proportional_gain (line 761) | def proportional_gain(self, newval):
      method derivative_gain (line 767) | def derivative_gain(self):
      method derivative_gain (line 776) | def derivative_gain(self, newval):
      method integral_gain (line 782) | def integral_gain(self):
      method integral_gain (line 791) | def integral_gain(self, newval):
      method integral_saturation_gain (line 797) | def integral_saturation_gain(self):
      method integral_saturation_gain (line 806) | def integral_saturation_gain(self, newval):
      method encoder_position (line 812) | def encoder_position(self):
      method search_for_home (line 823) | def search_for_home(self, search_mode=None):
      method move (line 836) | def move(self, position, absolute=True, wait=False, block=False):
      method move_to_hardware_limit (line 864) | def move_to_hardware_limit(self):
      method move_indefinitely (line 870) | def move_indefinitely(self):
      method abort_motion (line 876) | def abort_motion(self):
      method wait_for_stop (line 882) | def wait_for_stop(self):
      method stop_motion (line 888) | def stop_motion(self):
      method wait_for_position (line 894) | def wait_for_position(self, position):
      method wait_for_motion (line 907) | def wait_for_motion(self, poll_interval=0.01, max_wait=None):
      method enable (line 936) | def enable(self):
      method disable (line 942) | def disable(self):
      method setup_axis (line 948) | def setup_axis(self, **kwargs):
      method read_setup (line 1042) | def read_setup(self):
      method get_status (line 1105) | def get_status(self):
      method _get_pq_unit (line 1126) | def _get_pq_unit(num):
      method _get_unit_num (line 1135) | def _get_unit_num(self, quantity):
      method _newport_cmd (line 1151) | def _newport_cmd(self, cmd, **kwargs):
    class HomeSearchMode (line 1163) | class HomeSearchMode(IntEnum):
    class MotorType (line 1183) | class MotorType(IntEnum):
    class Units (line 1194) | class Units(IntEnum):
    method axis (line 1215) | def axis(self):
    method _newport_cmd (line 1236) | def _newport_cmd(self, cmd, params=tuple(), target=None, errcheck=True):
    method _execute_cmd (line 1269) | def _execute_cmd(self, raw_cmd, errcheck=True):
    method _home (line 1302) | def _home(self, axis, search_mode, errcheck=True):
    method search_for_home (line 1310) | def search_for_home(
    method reset (line 1329) | def reset(self):
    method define_program (line 1341) | def define_program(self, program_id):
    method execute_bulk_command (line 1370) | def execute_bulk_command(self, errcheck=True):
    method run_program (line 1391) | def run_program(self, program_id):

FILE: src/instruments/ondax/lm.py
  class LM (line 21) | class LM(Instrument):
    method __init__ (line 30) | def __init__(self, filelike):
    class Status (line 40) | class Status(IntEnum):
    class _AutomaticCurrentControl (line 56) | class _AutomaticCurrentControl:
      method __init__ (line 65) | def __init__(self, parent):
      method target (line 70) | def target(self):
      method enabled (line 90) | def enabled(self):
      method enabled (line 108) | def enabled(self, newval):
      method on (line 120) | def on(self):
      method off (line 134) | def off(self):
    class _AutomaticPowerControl (line 148) | class _AutomaticPowerControl:
      method __init__ (line 157) | def __init__(self, parent):
      method target (line 162) | def target(self):
      method enabled (line 182) | def enabled(self):
      method enabled (line 200) | def enabled(self, newval):
      method start (line 212) | def start(self):
      method stop (line 226) | def stop(self):
    class _Modulation (line 240) | class _Modulation:
      method __init__ (line 248) | def __init__(self, parent):
      method on_time (line 253) | def on_time(self):
      method on_time (line 276) | def on_time(self, newval):
      method off_time (line 281) | def off_time(self):
      method off_time (line 304) | def off_time(self, newval):
      method enabled (line 309) | def enabled(self):
      method enabled (line 327) | def enabled(self, newval):
    class _ThermoElectricCooler (line 339) | class _ThermoElectricCooler:
      method __init__ (line 348) | def __init__(self, parent):
      method current (line 353) | def current(self):
      method target (line 372) | def target(self):
      method enabled (line 391) | def enabled(self):
      method enabled (line 409) | def enabled(self, newval):
    method _ack_expected (line 421) | def _ack_expected(self, msg=""):
    method firmware (line 428) | def firmware(self):
    method current (line 438) | def current(self):
    method current (line 450) | def current(self, newval):
    method maximum_current (line 455) | def maximum_current(self):
    method maximum_current (line 468) | def maximum_current(self, newval):
    method power (line 473) | def power(self):
    method power (line 485) | def power(self, newval):
    method serial_number (line 490) | def serial_number(self):
    method status (line 500) | def status(self):
    method temperature (line 510) | def temperature(self):
    method temperature (line 522) | def temperature(self, newval):
    method enabled (line 527) | def enabled(self):
    method enabled (line 536) | def enabled(self, newval):
    method save (line 548) | def save(self):
    method reset (line 554) | def reset(self):

FILE: src/instruments/oxford/oxforditc503.py
  class OxfordITC503 (line 15) | class OxfordITC503(Instrument):
    method __init__ (line 27) | def __init__(self, filelike):
    class Sensor (line 34) | class Sensor:
      method __init__ (line 42) | def __init__(self, parent, idx):
      method temperature (line 49) | def temperature(self):
    method sensor (line 62) | def sensor(self):

FILE: src/instruments/pfeiffer/tpg36x.py
  class TPG36x (line 18) | class TPG36x(Instrument):
    method __init__ (line 33) | def __init__(self, filelike):
    class EthernetMode (line 47) | class EthernetMode(Enum):
    class Language (line 53) | class Language(Enum):
    class Unit (line 60) | class Unit(Enum):
    class Channel (line 70) | class Channel:
      class SensorStatus (line 78) | class SensorStatus(Enum):
      method __init__ (line 85) | def __init__(self, parent, chan):
      method pressure (line 92) | def pressure(self):
      method status (line 134) | def status(self):
      method status (line 153) | def status(self, value):
    method channel (line 164) | def channel(self):
    method ethernet_configuration (line 180) | def ethernet_configuration(self):
    method ethernet_configuration (line 207) | def ethernet_configuration(self, value):
    method language (line 225) | def language(self):
    method language (line 241) | def language(self, value):
    method mac_address (line 245) | def mac_address(self):
    method name (line 261) | def name(self):
    method number_channels (line 276) | def number_channels(self):
    method number_channels (line 294) | def number_channels(self, value):
    method pressure (line 300) | def pressure(self):
    method unit (line 318) | def unit(self):
    method unit (line 336) | def unit(self, new_unit):
    method query (line 342) | def query(self, cmd):
    method _ack_expected (line 352) | def _ack_expected(self, msg=""):

FILE: src/instruments/phasematrix/phasematrix_fsw0020.py
  class PhaseMatrixFSW0020 (line 16) | class PhaseMatrixFSW0020(SingleChannelSG):
    method reset (line 31) | def reset(self):
    method frequency (line 40) | def frequency(self):
    method frequency (line 52) | def frequency(self, newval):
    method power (line 64) | def power(self):
    method power (line 76) | def power(self, newval):
    method phase (line 88) | def phase(self):
    method phase (line 92) | def phase(self, newval):
    method blanking (line 96) | def blanking(self):
    method blanking (line 105) | def blanking(self, newval):
    method ref_output (line 109) | def ref_output(self):
    method ref_output (line 118) | def ref_output(self, newval):
    method output (line 122) | def output(self):
    method output (line 132) | def output(self, newval):
    method pulse_modulation (line 136) | def pulse_modulation(self):
    method pulse_modulation (line 145) | def pulse_modulation(self, newval):
    method am_modulation (line 149) | def am_modulation(self):
    method am_modulation (line 158) | def am_modulation(self, newval):

FILE: src/instruments/picowatt/picowattavs47.py
  class PicowattAVS47 (line 17) | class PicowattAVS47(SCPIInstrument):
    method __init__ (line 29) | def __init__(self, filelike):
    class Sensor (line 35) | class Sensor:
      method __init__ (line 43) | def __init__(self, parent, idx):
      method resistance (line 48) | def resistance(self):
    class InputSource (line 67) | class InputSource(IntEnum):
    method sensor (line 79) | def sensor(self):

FILE: src/instruments/qubitekk/cc1.py
  class CC1 (line 19) | class CC1(SCPIInstrument):
    method __init__ (line 33) | def __init__(self, filelike):
    method _ack_expected (line 63) | def _ack_expected(self, msg=""):
    class _TriggerModeNew (line 72) | class _TriggerModeNew(Enum):
    class _TriggerModeOld (line 80) | class _TriggerModeOld(Enum):
    class Channel (line 90) | class Channel:
      method __init__ (line 97) | def __init__(self, cc1, idx):
      method count (line 108) | def count(self):
    method acknowledge (line 137) | def acknowledge(self):
    method acknowledge (line 150) | def acknowledge(self, new_val):
    method gate (line 164) | def gate(self):
    method gate (line 173) | def gate(self, newval):
    method subtract (line 181) | def subtract(self):
    method subtract (line 190) | def subtract(self, newval):
    method trigger_mode (line 198) | def trigger_mode(self):
    method trigger_mode (line 208) | def trigger_mode(self, newval):
    method window (line 219) | def window(self):
    method window (line 230) | def window(self, new_val):
    method delay (line 238) | def delay(self):
    method delay (line 250) | def delay(self, new_val):
    method dwell_time (line 259) | def dwell_time(self):
    method dwell_time (line 277) | def dwell_time(self, new_val):
    method firmware (line 284) | def firmware(self):
    method channel (line 308) | def channel(self):
    method clear_counts (line 324) | def clear_counts(self):

FILE: src/instruments/qubitekk/mc1.py
  class MC1 (line 24) | class MC1(Instrument):
    method __init__ (line 30) | def __init__(self, filelike):
    class MotorType (line 41) | class MotorType(Enum):
    method increment (line 52) | def increment(self):
    method increment (line 62) | def increment(self, newval):
    method lower_limit (line 66) | def lower_limit(self):
    method lower_limit (line 76) | def lower_limit(self, newval):
    method upper_limit (line 80) | def upper_limit(self):
    method upper_limit (line 90) | def upper_limit(self, newval):
    method internal_position (line 122) | def internal_position(self):
    method firmware (line 176) | def firmware(self):
    method move_timeout (line 206) | def move_timeout(self):
    method is_centering (line 219) | def is_centering(self):
    method center (line 229) | def center(self):
    method reset (line 235) | def reset(self):
    method move (line 241) | def move(self, new_position):

FILE: src/instruments/rigol/rigolds1000.py
  class RigolDS1000Series (line 17) | class RigolDS1000Series(SCPIInstrument, Oscilloscope):
    class AcquisitionType (line 28) | class AcquisitionType(Enum):
    class DataSource (line 39) | class DataSource(Oscilloscope.DataSource):
      method name (line 49) | def name(self):
      method read_waveform (line 52) | def read_waveform(self, bin_format=True):
    class Channel (line 64) | class Channel(DataSource, Oscilloscope.Channel):
      class Coupling (line 74) | class Coupling(Enum):
      method __init__ (line 83) | def __init__(self, parent, idx):
      method sendcmd (line 90) | def sendcmd(self, cmd):
      method query (line 99) | def query(self, cmd):
    method channel (line 129) | def channel(self):
    method math (line 135) | def math(self):
    method ref (line 139) | def ref(self):
    method acquire_averages (line 147) | def acquire_averages(self):
    method acquire_averages (line 157) | def acquire_averages(self, newval):
    method force_trigger (line 171) | def force_trigger(self):
    method run (line 175) | def run(self):
    method stop (line 181) | def stop(self):
    method release_panel (line 198) | def release_panel(self):

FILE: src/instruments/srs/srs345.py
  class SRS345 (line 20) | class SRS345(SCPIInstrument, FunctionGenerator):
    method _get_amplitude_ (line 49) | def _get_amplitude_(self):
    method _set_amplitude_ (line 54) | def _set_amplitude_(self, magnitude, units):
    class Function (line 59) | class Function(IntEnum):

FILE: src/instruments/srs/srs830.py
  class SRS830 (line 37) | class SRS830(SCPIInstrument):
    method __init__ (line 50) | def __init__(self, filelike, outx_mode=None):
    class FreqSource (line 80) | class FreqSource(IntEnum):
    class Coupling (line 88) | class Coupling(IntEnum):
    class BufferMode (line 96) | class BufferMode(IntEnum):
    class Mode (line 104) | class Mode(Enum):
    method sample_rate (line 208) | def sample_rate(self):
    method sample_rate (line 223) | def sample_rate(self, newval):
    method num_data_points (line 251) | def num_data_points(self):
    method auto_offset (line 285) | def auto_offset(self, mode):
    method auto_phase (line 307) | def auto_phase(self):
    method init (line 319) | def init(self, sample_rate, buffer_mode):
    method start_data_transfer (line 338) | def start_data_transfer(self):
    method take_measurement (line 347) | def take_measurement(self, sample_rate, num_samples):
    method set_offset_expand (line 396) | def set_offset_expand(self, mode, offset, expand):
    method start_scan (line 437) | def start_scan(self):
    method pause (line 445) | def pause(self):
    method data_snap (line 465) | def data_snap(self, mode1, mode2):
    method read_data_buffer (line 507) | def read_data_buffer(self, channel):
    method clear_data_buffer (line 540) | def clear_data_buffer(self):
    method set_channel_display (line 564) | def set_channel_display(self, channel, display, ratio):

FILE: src/instruments/srs/srsctc100.py
  class SRSCTC100 (line 19) | class SRSCTC100(SCPIInstrument):
    method __init__ (line 25) | def __init__(self, filelike):
    class SensorType (line 44) | class SensorType(Enum):
    class Channel (line 54) | class Channel:
      method __init__ (line 60) | def __init__(self, ctc, chan_name):
      method _get (line 72) | def _get(self, prop_name):
      method _set (line 75) | def _set(self, prop_name, newval):
      method name (line 83) | def name(self):
      method name (line 94) | def name(self, newval):
      method value (line 103) | def value(self):
      method units (line 117) | def units(self):
      method sensor_type (line 134) | def sensor_type(self):
      method stats_enabled (line 147) | def stats_enabled(self):
      method stats_enabled (line 156) | def stats_enabled(self, newval):
      method stats_points (line 161) | def stats_points(self):
      method stats_points (line 171) | def stats_points(self, newval):
      method average (line 175) | def average(self):
      method std_dev (line 185) | def std_dev(self):
      method get_log_point (line 196) | def get_log_point(self, which="next", units=None):
      method get_log (line 221) | def get_log(self):
    method _channel_names (line 266) | def _channel_names(self):
    method channel_units (line 288) | def channel_units(self):
    method errcheck (line 305) | def errcheck(self):
    method _error_checking_disabled (line 322) | def _error_checking_disabled(self):
    method channel (line 330) | def channel(self):
    method display_figures (line 348) | def display_figures(self):
    method display_figures (line 358) | def display_figures(self, newval):
    method error_check_toggle (line 367) | def error_check_toggle(self):
    method error_check_toggle (line 376) | def error_check_toggle(self, newval):
    method sendcmd (line 385) | def sendcmd(self, cmd):
    method query (line 390) | def query(self, cmd, size=-1):
    method clear_log (line 398) | def clear_log(self):

FILE: src/instruments/srs/srsdg645.py
  class SRSDG645 (line 18) | class SRSDG645(SCPIInstrument):
    class Channel (line 34) | class Channel:
      method __init__ (line 42) | def __init__(self, parent, chan):
      method idx (line 56) | def idx(self):
      method delay (line 67) | def delay(self):
      method delay (line 80) | def delay(self, newval):
    method __init__ (line 88) | def __init__(self, filelike):
    class LevelPolarity (line 97) | class LevelPolarity(IntEnum):
    class Outputs (line 105) | class Outputs(IntEnum):
    class Channels (line 116) | class Channels(IntEnum):
    class DisplayMode (line 132) | class DisplayMode(IntEnum):
    class TriggerSource (line 153) | class TriggerSource(IntEnum):
    class Output (line 168) | class Output:
      method __init__ (line 173) | def __init__(self, parent, idx):
      method polarity (line 178) | def polarity(self):
      method polarity (line 189) | def polarity(self, newval):
      method level_amplitude (line 199) | def level_amplitude(self):
      method level_amplitude (line 209) | def level_amplitude(self, newval):
      method level_offset (line 214) | def level_offset(self):
      method level_offset (line 224) | def level_offset(self, newval):
    method channel (line 231) | def channel(self):
    method output (line 249) | def output(self):
    method display (line 258) | def display(self):
    method display (line 269) | def display(self, newval):
    method enable_adv_triggering (line 274) | def enable_adv_triggering(self):
    method enable_adv_triggering (line 283) | def enable_adv_triggering(self, newval):
    method trigger_rate (line 287) | def trigger_rate(self):
    method trigger_rate (line 297) | def trigger_rate(self, newval):
    method trigger_source (line 302) | def trigger_source(self):
    method trigger_source (line 311) | def trigger_source(self, newval):
    method holdoff (line 315) | def holdoff(self):
    method holdoff (line 325) | def holdoff(self, newval):
    method enable_burst_mode (line 330) | def enable_burst_mode(self):
    method enable_burst_mode (line 339) | def enable_burst_mode(self, newval):
    method enable_burst_t0_first (line 343) | def enable_burst_t0_first(self):
    method enable_burst_t0_first (line 355) | def enable_burst_t0_first(self, newval):
    method burst_count (line 359) | def burst_count(self):
    method burst_count (line 368) | def burst_count(self, newval):
    method burst_period (line 372) | def burst_period(self):
    method burst_period (line 383) | def burst_period(self, newval):
    method burst_delay (line 388) | def burst_delay(self):
    method burst_delay (line 400) | def burst_delay(self, newval):

FILE: src/instruments/sunpower/cryotel_gt.py
  class CryoTelGT (line 19) | class CryoTelGT(Instrument):
    class ControlMode (line 43) | class ControlMode(Enum):
    class ThermostatStatus (line 51) | class ThermostatStatus(Enum):
    class StopMode (line 62) | class StopMode(Enum):
    method __init__ (line 72) | def __init__(self, filelike):
    method at_temperature_band (line 89) | def at_temperature_band(self):
    method at_temperature_band (line 104) | def at_temperature_band(self, value):
    method control_mode (line 109) | def control_mode(self):
    method control_mode (line 124) | def control_mode(self, value):
    method errors (line 132) | def errors(self):
    method ki (line 148) | def ki(self):
    method ki (line 161) | def ki(self, value):
    method kp (line 165) | def kp(self):
    method kp (line 178) | def kp(self, value):
    method power (line 182) | def power(self):
    method power_current_and_limits (line 192) | def power_current_and_limits(self):
    method power_max (line 207) | def power_max(self):
    method power_max (line 220) | def power_max(self, value):
    method power_min (line 227) | def power_min(self):
    method power_min (line 240) | def power_min(self, value):
    method power_setpoint (line 247) | def power_setpoint(self):
    method power_setpoint (line 266) | def power_setpoint(self, value):
    method serial_number (line 273) | def serial_number(self):
    method state (line 282) | def state(self):
    method temperature (line 294) | def temperature(self):
    method temperature_setpoint (line 304) | def temperature_setpoint(self):
    method temperature_setpoint (line 318) | def temperature_setpoint(self, value):
    method thermostat (line 323) | def thermostat(self):
    method thermostat (line 335) | def thermostat(self, value):
    method thermostat_status (line 341) | def thermostat_status(self):
    method stop (line 355) | def stop(self):
    method stop (line 367) | def stop(self, value):
    method stop_mode (line 373) | def stop_mode(self):
    method stop_mode (line 385) | def stop_mode(self, value):
    method reset (line 392) | def reset(self):
    method save_control_mode (line 398) | def save_control_mode(self):
    method query (line 406) | def query(self, command, value=None):
    method query_multiline (line 437) | def query_multiline(self, command, num_lines):
    method sendcmd (line 452) | def sendcmd(self, command):

FILE: src/instruments/tektronix/tekawg2000.py
  class TekAWG2000 (line 18) | class TekAWG2000(SCPIInstrument):
    class Channel (line 26) | class Channel:
      method __init__ (line 34) | def __init__(self, tek, idx):
      method name (line 46) | def name(self):
      method amplitude (line 55) | def amplitude(self):
      method amplitude (line 68) | def amplitude(self, newval):
      method offset (line 76) | def offset(self):
      method offset (line 89) | def offset(self, newval):
      method frequency (line 97) | def frequency(self):
      method frequency (line 109) | def frequency(self, newval):
      method polarity (line 115) | def polarity(self):
      method polarity (line 124) | def polarity(self, newval):
      method shape (line 135) | def shape(self):
      method shape (line 147) | def shape(self, newval):
    class Polarity (line 157) | class Polarity(Enum):
    class Shape (line 165) | class Shape(Enum):
    method waveform_name (line 179) | def waveform_name(self):
    method waveform_name (line 191) | def waveform_name(self, newval):
    method channel (line 197) | def channel(self):
    method upload_waveform (line 215) | def upload_waveform(self, yzero, ymult, xincr, waveform):

FILE: src/instruments/tektronix/tekdpo4104.py
  function _parent_property (line 20) | def _parent_property(prop_name, doc=""):
  class TekDPO4104 (line 38) | class TekDPO4104(SCPIInstrument, Oscilloscope):
    class DataSource (line 52) | class DataSource(Oscilloscope.DataSource):
      method __init__ (line 61) | def __init__(self, tek, name):
      method name (line 66) | def name(self):
      method __enter__ (line 74) | def __enter__(self):
      method __exit__ (line 83) | def __exit__(self, type, value, traceback):
      method __eq__ (line 87) | def __eq__(self, other):
      method read_waveform (line 95) | def read_waveform(self, bin_format=True):
    class Channel (line 162) | class Channel(DataSource, Oscilloscope.Channel):
      method __init__ (line 172) | def __init__(self, parent, idx):
      method coupling (line 177) | def coupling(self):
      method coupling (line 186) | def coupling(self, newval):
    class Coupling (line 197) | class Coupling(Enum):
    method channel (line 210) | def channel(self):
    method ref (line 225) | def ref(self):
    method math (line 245) | def math(self):
    method data_source (line 254) | def data_source(self):
    method data_source (line 265) | def data_source(self, newval):
    method aquisition_length (line 276) | def aquisition_length(self):
    method aquisition_length (line 285) | def aquisition_length(self, newval):
    method aquisition_running (line 289) | def aquisition_running(self):
    method aquisition_running (line 300) | def aquisition_running(self, newval):
    method aquisition_continuous (line 304) | def aquisition_continuous(self):
    method aquisition_continuous (line 314) | def aquisition_continuous(self, newval):
    method data_width (line 318) | def data_width(self):
    method data_width (line 330) | def data_width(self, newval):
    method y_offset (line 338) | def y_offset(self):
    method y_offset (line 346) | def y_offset(self, newval):
    method force_trigger (line 351) | def force_trigger(self):

FILE: src/instruments/tektronix/tekdpo70000.py
  class TekDPO70000 (line 31) | class TekDPO70000(SCPIInstrument, Oscilloscope):
    class AcquisitionMode (line 53) | class AcquisitionMode(Enum):
    class AcquisitionState (line 66) | class AcquisitionState(Enum):
    class StopAfter (line 77) | class StopAfter(Enum):
    class SamplingMode (line 86) | class SamplingMode(Enum):
    class HorizontalMode (line 96) | class HorizontalMode(Enum):
    class WaveformEncoding (line 106) | class WaveformEncoding(Enum):
    class BinaryFormat (line 117) | class BinaryFormat(Enum):
    class ByteOrder (line 127) | class ByteOrder(Enum):
    class TriggerState (line 136) | class TriggerState(Enum):
    method _dtype (line 151) | def _dtype(binary_format, byte_order, n_bytes):
    class DataSource (line 167) | class DataSource(Oscilloscope.DataSource):
      method name (line 177) | def name(self):
      method _scale_raw_data (line 181) | def _scale_raw_data(self, data):
      method read_waveform (line 187) | def read_waveform(self, bin_format=True):
      method __enter__ (line 205) | def __enter__(self):
      method __exit__ (line 214) | def __exit__(self, type, value, traceback):
    class Math (line 218) | class Math(DataSource):
      method __init__ (line 228) | def __init__(self, parent, idx):
      method sendcmd (line 235) | def sendcmd(self, cmd):
      method query (line 244) | def query(self, cmd, size=-1):
      class FilterMode (line 257) | class FilterMode(Enum):
      class Mag (line 266) | class Mag(Enum):
      class Phase (line 276) | class Phase(Enum):
      class SpectralWindow (line 286) | class SpectralWindow(Enum):
      method _scale_raw_data (line 471) | def _scale_raw_data(self, data):
    class Channel (line 487) | class Channel(DataSource, Oscilloscope.Channel):
      method __init__ (line 497) | def __init__(self, parent, idx):
      method sendcmd (line 504) | def sendcmd(self, cmd):
      method query (line 513) | def query(self, cmd, size=-1):
      class Coupling (line 526) | class Coupling(Enum):
      method _scale_raw_data (line 605) | def _scale_raw_data(self, data):
    method channel (line 628) | def channel(self):
    method math (line 632) | def math(self):
    method ref (line 636) | def ref(self):
    method data_source (line 754) | def data_source(self):
    method data_source (line 775) | def data_source(self, newval):
    method select_fastest_encoding (line 932) | def select_fastest_encoding(self):
    method force_trigger (line 939) | def force_trigger(self):
    method run (line 946) | def run(self):
    method stop (line 952) | def stop(self):

FILE: src/instruments/tektronix/tektds224.py
  class TekTDS224 (line 21) | class TekTDS224(SCPIInstrument, Oscilloscope):
    method __init__ (line 35) | def __init__(self, filelike):
    class DataSource (line 39) | class DataSource(Oscilloscope.DataSource):
      method __init__ (line 48) | def __init__(self, tek, name):
      method name (line 53) | def name(self):
      method read_waveform (line 61) | def read_waveform(self, bin_format=True):
    class Channel (line 127) | class Channel(DataSource, Oscilloscope.Channel):
      method __init__ (line 137) | def __init__(self, parent, idx):
      method coupling (line 142) | def coupling(self):
      method coupling (line 151) | def coupling(self, newval):
    class Coupling (line 161) | class Coupling(Enum):
    method channel (line 173) | def channel(self):
    method ref (line 189) | def ref(self):
    method math (line 207) | def math(self):
    method data_source (line 216) | def data_source(self):
    method data_source (line 227) | def data_source(self, newval):
    method data_width (line 238) | def data_width(self):
    method data_width (line 248) | def data_width(self, newval):
    method force_trigger (line 254) | def force_trigger(self):

FILE: src/instruments/tektronix/tektds5xx.py
  class TekTDS5xx (line 51) | class TekTDS5xx(SCPIInstrument, Oscilloscope):
    class Measurement (line 61) | class Measurement:
      method __init__ (line 66) | def __init__(self, tek, idx):
      method read (line 86) | def read(self):
    class DataSource (line 100) | class DataSource(Oscilloscope.DataSource):
      method name (line 110) | def name(self):
      method read_waveform (line 118) | def read_waveform(self, bin_format=True):
    class Channel (line 180) | class Channel(DataSource, Oscilloscope.Channel):
      method __init__ (line 190) | def __init__(self, parent, idx):
      method coupling (line 195) | def coupling(self):
      method coupling (line 204) | def coupling(self, newval):
      method bandwidth (line 214) | def bandwidth(self):
      method bandwidth (line 223) | def bandwidth(self, newval):
      method impedance (line 233) | def impedance(self):
      method impedance (line 242) | def impedance(self, newval):
      method probe (line 252) | def probe(self):
      method scale (line 261) | def scale(self):
      method scale (line 270) | def scale(self, newval):
    class Coupling (line 281) | class Coupling(Enum):
    class Bandwidth (line 290) | class Bandwidth(Enum):
    class Impedance (line 300) | class Impedance(Enum):
    class Edge (line 308) | class Edge(Enum):
    class Trigger (line 316) | class Trigger(Enum):
    class Source (line 329) | class Source(Enum):
    method measurement (line 348) | def measurement(self):
    method channel (line 358) | def channel(self):
    method ref (line 373) | def ref(self):
    method math (line 392) | def math(self):
    method sources (line 405) | def sources(self):
    method data_source (line 425) | def data_source(self):
    method data_source (line 439) | def data_source(self, newval):
    method data_width (line 452) | def data_width(self):
    method data_width (line 461) | def data_width(self, newval):
    method force_trigger (line 467) | def force_trigger(self):
    method horizontal_scale (line 471) | def horizontal_scale(self):
    method horizontal_scale (line 480) | def horizontal_scale(self, newval):
    method trigger_level (line 490) | def trigger_level(self):
    method trigger_level (line 499) | def trigger_level(self, newval):
    method trigger_coupling (line 509) | def trigger_coupling(self):
    method trigger_coupling (line 518) | def trigger_coupling(self, newval):
    method trigger_slope (line 528) | def trigger_slope(self):
    method trigger_slope (line 537) | def trigger_slope(self, newval):
    method trigger_source (line 547) | def trigger_source(self):
    method trigger_source (line 556) | def trigger_source(self, newval):
    method clock (line 567) | def clock(self):
    method clock (line 577) | def clock(self, newval):
    method display_clock (line 585) | def display_clock(self):
    method display_clock (line 594) | def display_clock(self, newval):
    method get_hardcopy (line 599) | def get_hardcopy(self):

FILE: src/instruments/teledyne/maui.py
  class MAUI (line 30) | class MAUI(Oscilloscope):
    method __init__ (line 72) | def __init__(self, filelike):
    class MeasurementParameters (line 85) | class MeasurementParameters(Enum):
    class TriggerState (line 117) | class TriggerState(Enum):
    class TriggerType (line 127) | class TriggerType(Enum):
    class TriggerSource (line 148) | class TriggerSource(Enum):
    method _create_trigger_source_enum (line 171) | def _create_trigger_source_enum(self):
    class DataSource (line 191) | class DataSource(Oscilloscope.DataSource):
      method name (line 203) | def name(self):
      method read_waveform (line 208) | def read_waveform(self, bin_format=False, single=True):
    class Channel (line 313) | class Channel(DataSource, Oscilloscope.Channel):
      method __init__ (line 321) | def __init__(self, parent, idx):
      class Coupling (line 330) | class Coupling(Enum):
      method offset (line 360) | def offset(self):
      method offset (line 375) | def offset(self, newval):
      method scale (line 380) | def scale(self):
      method scale (line 394) | def scale(self, newval):
      method sendcmd (line 400) | def sendcmd(self, cmd):
      method query (line 409) | def query(self, cmd, size=-1):
    class Math (line 425) | class Math(DataSource):
      method __init__ (line 433) | def __init__(self, parent, idx):
      class Operators (line 442) | class Operators:
        method __init__ (line 463) | def __init__(self, parent):
        method current_setting (line 469) | def current_setting(self):
        method absolute (line 478) | def absolute(self, src):
        method average (line 488) | def average(self, src, average_type="summed", sweeps=1000):
        method derivative (line 510) | def derivative(self, src, vscale=1e6, voffset=0, autoscale=True):
        method difference (line 538) | def difference(self, src1, src2, vscale_variable=False):
        method envelope (line 562) | def envelope(self, src, sweeps=1000, limit_sweeps=True):
        method eres (line 576) | def eres(self, src, bits=0.5):
        method fft (line 595) | def fft(
        method floor (line 645) | def floor(self, src, sweeps=1000, limit_sweeps=True):
        method integral (line 659) | def integral(self, src, multiplier=1, adder=0, vscale=1e-3, voffse...
        method invert (line 682) | def invert(self, src):
        method product (line 691) | def product(self, src1, src2):
        method ratio (line 705) | def ratio(self, src1, src2):
        method reciprocal (line 719) | def reciprocal(self, src):
        method rescale (line 728) | def rescale(self, src, multiplier=1, adder=0):
        method sinx (line 747) | def sinx(self, src):
        method square (line 756) | def square(self, src):
        method square_root (line 765) | def square_root(self, src):
        method sum (line 774) | def sum(self, src1, src2):
        method trend (line 788) | def trend(self, src, vscale=1, center=0, autoscale=True):
        method roof (line 813) | def roof(self, src, sweeps=1000, limit_sweeps=True):
        method _send_operator (line 827) | def _send_operator(self, cmd):
      method operator (line 836) | def operator(self):
      method clear_sweeps (line 854) | def clear_sweeps(self):
      method sendcmd (line 858) | def sendcmd(self, cmd):
      method query (line 867) | def query(self, cmd, size=-1):
    class Measurement (line 883) | class Measurement:
      method __init__ (line 891) | def __init__(self, parent, idx):
      class State (line 897) | class State(Enum):
      method statistics (line 927) | def statistics(self):
      method delete (line 959) | def delete(self):
      method set_parameter (line 965) | def set_parameter(self, param, src):
      method sendcmd (line 999) | def sendcmd(self, cmd):
      method query (line 1008) | def query(self, cmd, size=-1):
    method channel (line 1027) | def channel(self):
    method math (line 1041) | def math(self):
    method measurement (line 1055) | def measurement(self):
    method ref (line 1069) | def ref(self):
    method number_channels (line 1075) | def number_channels(self):
    method number_channels (line 1091) | def number_channels(self, newval):
    method number_functions (line 1097) | def number_functions(self):
    method number_functions (line 1113) | def number_functions(self, newval):
    method number_measurements (line 1117) | def number_measurements(self):
    method number_measurements (line 1133) | def number_measurements(self, newval):
    method self_test (line 1137) | def self_test(self):
    method show_id (line 1159) | def show_id(self):
    method show_options (line 1174) | def show_options(self):
    method time_div (line 1190) | def time_div(self):
    method time_div (line 1204) | def time_div(self, newval):
    method trigger_delay (line 1226) | def trigger_delay(self):
    method trigger_delay (line 1241) | def trigger_delay(self, newval):
    method trigger_source (line 1246) | def trigger_source(self):
    method trigger_source (line 1274) | def trigger_source(self, newval):
    method trigger_type (line 1280) | def trigger_type(self):
    method trigger_type (line 1303) | def trigger_type(self, newval):
    method clear_sweeps (line 1310) | def clear_sweeps(self):
    method force_trigger (line 1321) | def force_trigger(self):
    method run (line 1332) | def run(self):
    method stop (line 1343) | def stop(self):
  function _source (line 1358) | def _source(src):

FILE: src/instruments/thorlabs/_abstract.py
  class ThorLabsInstrument (line 20) | class ThorLabsInstrument(Instrument):
    method __init__ (line 26) | def __init__(self, filelike):
    method sendpacket (line 30) | def sendpacket(self, packet):
    method querypacket (line 42) | def querypacket(self, packet, expect=None, timeout=None, expect_data_l...

FILE: src/instruments/thorlabs/_cmds.py
  class ThorLabsCommands (line 15) | class ThorLabsCommands(IntEnum):

FILE: src/instruments/thorlabs/_packets.py
  class ThorLabsPacket (line 31) | class ThorLabsPacket:
    method __init__ (line 39) | def __init__(
    method __str__ (line 62) | def __str__(self):
    method message_id (line 79) | def message_id(self):
    method message_id (line 88) | def message_id(self, newval):
    method parameters (line 92) | def parameters(self):
    method parameters (line 101) | def parameters(self, newval):
    method destination (line 105) | def destination(self):
    method destination (line 114) | def destination(self, newval):
    method source (line 118) | def source(self):
    method source (line 127) | def source(self, newval):
    method data (line 131) | def data(self):
    method data (line 140) | def data(self, newval):
    method pack (line 143) | def pack(self):
    method unpack (line 161) | def unpack(cls, bytes):

FILE: src/instruments/thorlabs/lcc25.py
  class LCC25 (line 21) | class LCC25(Instrument):
    method __init__ (line 31) | def __init__(self, filelike):
    method _ack_expected (line 36) | def _ack_expected(self, msg=""):
    class Mode (line 41) | class Mode(IntEnum):
    method name (line 53) | def name(self):
    method default (line 226) | def default(self):
    method save (line 237) | def save(self):
    method set_settings (line 248) | def set_settings(self, slot):
    method get_settings (line 263) | def get_settings(self, slot):
    method test_mode (line 278) | def test_mode(self):

FILE: src/instruments/thorlabs/pm100usb.py
  class PM100USB (line 27) | class PM100USB(SCPIInstrument):
    class SensorFlags (line 39) | class SensorFlags(IntEnum):
    class MeasurementConfiguration (line 51) | class MeasurementConfiguration(Enum):
    class Sensor (line 76) | class Sensor:
      method __init__ (line 84) | def __init__(self, parent):
      method name (line 109) | def name(self):
      method serial_number (line 118) | def serial_number(self):
      method calibration_message (line 127) | def calibration_message(self):
      method type (line 136) | def type(self):
      method flags (line 145) | def flags(self):
    method cache_units (line 160) | def cache_units(self):
    method cache_units (line 176) | def cache_units(self, newval):
    method sensor (line 184) | def sensor(self):
    method averaging_count (line 206) | def averaging_count(self):
    method averaging_count (line 214) | def averaging_count(self, newval):
    method read (line 231) | def read(self, size=-1, encoding="utf-8"):

FILE: src/instruments/thorlabs/sc10.py
  class SC10 (line 25) | class SC10(Instrument):
    method __init__ (line 32) | def __init__(self, filelike):
    method _ack_expected (line 37) | def _ack_expected(self, msg=""):
    class Mode (line 42) | class Mode(IntEnum):
    method name (line 56) | def name(self):
    method enable (line 66) | def enable(self):
    method enable (line 80) | def enable(self, value):
    method baud_rate (line 169) | def baud_rate(self):
    method baud_rate (line 181) | def baud_rate(self, newval):
    method default (line 218) | def default(self):
    method save (line 229) | def save(self):
    method save_mode (line 240) | def save_mode(self):
    method restore (line 251) | def restore(self):

FILE: src/instruments/thorlabs/tc200.py
  class TC200 (line 24) | class TC200(Instrument):
    method __init__ (line 34) | def __init__(self, filelike):
    method _ack_expected (line 39) | def _ack_expected(self, msg=""):
    class Mode (line 44) | class Mode(IntEnum):
    class Sensor (line 52) | class Sensor(Enum):
    method name (line 64) | def name(self):
    method mode (line 75) | def mode(self):
    method mode (line 86) | def mode(self, newval):
    method enable (line 104) | def enable(self):
    method enable (line 116) | def enable(self, newval):
    method status (line 141) | def status(self):
    method temperature_set (line 186) | def temperature_set(self):
    method temperature_set (line 206) | def temperature_set(self, newval):
    method p (line 215) | def p(self):
    method p (line 225) | def p(self, newval):
    method i (line 231) | def i(self):
    method i (line 241) | def i(self, newval):
    method d (line 247) | def d(self):
    method d (line 257) | def d(self, newval):
    method pid (line 263) | def pid(self):
    method pid (line 277) | def pid(self, newval):
    method degrees (line 288) | def degrees(self):
    method degrees (line 304) | def degrees(self, newval):

FILE: src/instruments/thorlabs/thorlabs_utils.py
  function check_cmd (line 7) | def check_cmd(response):

FILE: src/instruments/thorlabs/thorlabsapt.py
  class ThorLabsAPT (line 29) | class ThorLabsAPT(_abstract.ThorLabsInstrument):
    class APTChannel (line 36) | class APTChannel:
      method __init__ (line 42) | def __init__(self, apt, idx_chan):
      method enabled (line 49) | def enabled(self):
      method enabled (line 81) | def enabled(self, newval):
    method __init__ (line 94) | def __init__(self, filelike):
    method serial_number (line 163) | def serial_number(self):
    method model_number (line 172) | def model_number(self):
    method name (line 181) | def name(self):
    method channel (line 200) | def channel(self):
    method n_channels (line 212) | def n_channels(self):
    method n_channels (line 221) | def n_channels(self, nch):
    method identify (line 235) | def identify(self):
    method destination (line 251) | def destination(self):
  class APTPiezoDevice (line 260) | class APTPiezoDevice(ThorLabsAPT):
    class PiezoDeviceChannel (line 266) | class PiezoDeviceChannel(ThorLabsAPT.APTChannel):
      method max_travel (line 277) | def max_travel(self):
    method led_intensity (line 305) | def led_intensity(self):
    method led_intensity (line 331) | def led_intensity(self, intensity):
  class APTPiezoInertiaActuator (line 346) | class APTPiezoInertiaActuator(APTPiezoDevice):
    class PiezoChannel (line 372) | class PiezoChannel(APTPiezoDevice.PiezoDeviceChannel):
      method drive_op_parameters (line 381) | def drive_op_parameters(self):
      method drive_op_parameters (line 456) | def drive_op_parameters(self, params):
      method enabled_single (line 496) | def enabled_single(self):
      method enabled_single (line 542) | def enabled_single(self, newval):
      method jog_parameters (line 562) | def jog_parameters(self):
      method jog_parameters (line 659) | def jog_parameters(self, params):
      method position_count (line 726) | def position_count(self):
      method position_count (line 764) | def position_count(self, pos):
      method move_abs (line 777) | def move_abs(self, pos):
      method move_jog (line 807) | def move_jog(self, direction="fwd"):
      method move_jog_stop (line 850) | def move_jog_stop(self):
    method enabled_multi (line 876) | def enabled_multi(self):
    method enabled_multi (line 936) | def enabled_multi(self, mode):
  class APTPiezoStage (line 969) | class APTPiezoStage(APTPiezoDevice):
    class PiezoChannel (line 974) | class PiezoChannel(APTPiezoDevice.PiezoDeviceChannel):
      method position_control_closed (line 983) | def position_control_closed(self):
      method change_position_control_mode (line 1004) | def change_position_control_mode(self, closed, smooth=True):
      method output_position (line 1024) | def output_position(self):
      method output_position (line 1046) | def output_position(self, pos):
  class APTStrainGaugeReader (line 1060) | class APTStrainGaugeReader(APTPiezoDevice):
    class StrainGaugeChannel (line 1067) | class StrainGaugeChannel(APTPiezoDevice.PiezoDeviceChannel):
  class APTMotorController (line 1078) | class APTMotorController(ThorLabsAPT):
    class MotorChannel (line 1104) | class MotorChannel(ThorLabsAPT.APTChannel):
      method motion_timeout (line 1190) | def motion_timeout(self):
      method motion_timeout (line 1200) | def motion_timeout(self, newval):
      method _set_scale (line 1205) | def _set_scale(self, motor_model):
      method set_scale (line 1232) | def set_scale(self, motor_model):
      method motor_model (line 1243) | def motor_model(self):
      method motor_model (line 1256) | def motor_model(self, newval):
      method backlash_correction (line 1263) | def backlash_correction(self):
      method backlash_correction (line 1305) | def backlash_correction(self, pos):
      method home_parameters (line 1333) | def home_parameters(self):
      method home_parameters (line 1391) | def home_parameters(self, values):
      method status_bits (line 1446) | def status_bits(self):
      method position (line 1487) | def position(self):
      method position_encoder (line 1509) | def position_encoder(self):
      method go_home (line 1531) | def go_home(self):
      method move (line 1550) | def move(self, pos, absolute=True):

FILE: src/instruments/toptica/topmode.py
  class TopMode (line 21) | class TopMode(Instrument):
    method __init__ (line 34) | def __init__(self, filelike):
    method _ack_expected (line 39) | def _ack_expected(self, msg=""):
    class CharmStatus (line 49) | class CharmStatus(IntEnum):
    class Laser (line 61) | class Laser:
      method __init__ (line 69) | def __init__(self, parent, idx):
      method serial_number (line 76) | def serial_number(self):
      method model (line 86) | def model(self):
      method wavelength (line 96) | def wavelength(self):
      method production_date (line 107) | def production_date(self):
      method enable (line 117) | def enable(self):
      method enable (line 128) | def enable(self, newval):
      method is_connected (line 140) | def is_connected(self):
      method on_time (line 152) | def on_time(self):
      method charm_status (line 163) | def charm_status(self):
      method temperature_control_status (line 174) | def temperature_control_status(self):
      method current_control_status (line 185) | def current_control_status(self):
      method tec_status (line 196) | def tec_status(self):
      method intensity (line 206) | def intensity(self):
      method mode_hop (line 217) | def mode_hop(self):
      method lock_start (line 228) | def lock_start(self):
      method first_mode_hop_time (line 248) | def first_mode_hop_time(self):
      method latest_mode_hop_time (line 264) | def latest_mode_hop_time(self):
      method correction_status (line 280) | def correction_status(self):
      method correction (line 292) | def correction(self):
    method execute (line 303) | def execute(self, command):
    method set (line 312) | def set(self, param, value):
    method reference (line 331) | def reference(self, param):
    method display (line 343) | def display(self, param):
    method laser (line 355) | def laser(self):
    method enable (line 372) | def enable(self):
    method enable (line 380) | def enable(self, newval):
    method locked (line 388) | def locked(self):
    method interlock (line 398) | def interlock(self):
    method firmware (line 408) | def firmware(self):
    method fpga_status (line 419) | def fpga_status(self):
    method serial_number (line 434) | def serial_number(self):
    method temperature_status (line 444) | def temperature_status(self):
    method current_status (line 456) | def current_status(self):
    method reboot (line 469) | def reboot(self):

FILE: src/instruments/toptica/toptica_utils.py
  function convert_toptica_boolean (line 10) | def convert_toptica_boolean(response):
  function convert_toptica_datetime (line 28) | def convert_toptica_datetime(response):

FILE: src/instruments/util_fns.py
  function assume_units (line 22) | def assume_units(value, units):
  function setattr_expression (line 46) | def setattr_expression(target, name_expr, value):
  function convert_temperature (line 75) | def convert_temperature(temperature, base):
  function split_unit_str (line 91) | def split_unit_str(s, default_units=u.dimensionless, lookup=None):
  function rproperty (line 142) | def rproperty(fget=None, fset=None, doc=None, readonly=False, writeonly=...
  function bool_property (line 164) | def bool_property(
  function enum_property (line 228) | def enum_property(
  function unitless_property (line 312) | def unitless_property(
  function int_property (line 363) | def int_property(
  function unitful_property (line 429) | def unitful_property(
  function bounded_unitful_property (line 537) | def bounded_unitful_property(
  function string_property (line 614) | def string_property(
  class ProxyList (line 672) | class ProxyList:
    method __init__ (line 694) | def __init__(self, parent, proxy_cls, valid_set):
    method __iter__ (line 707) | def __iter__(self):
    method __getitem__ (line 711) | def __getitem__(self, idx):
    method __len__ (line 734) | def __len__(self):

FILE: src/instruments/yokogawa/yokogawa6370.py
  class Yokogawa6370 (line 27) | class Yokogawa6370(OpticalSpectrumAnalyzer):
    method __init__ (line 45) | def __init__(self, filelike, auth=None):
    method _authenticate (line 59) | def _authenticate(self, auth):
    class Channel (line 73) | class Channel(OpticalSpectrumAnalyzer.Channel):
      method __init__ (line 82) | def __init__(self, parent, idx):
      method _data (line 88) | def _data(self, axis, limits=None, bin_format=True):
      method data (line 107) | def data(self, limits=None, bin_format=True):
      method wavelength (line 117) | def wavelength(self, limits=None, bin_format=True):
    class SweepModes (line 129) | class SweepModes(IntEnum):
    class Traces (line 138) | class Traces(Enum):
    method channel (line 190) | def channel(self):
    method data (line 277) | def data(self, limits=None):
    method wavelength (line 287) | def wavelength(self, limits=None):
    method analysis (line 297) | def analysis(self):
    method start_sweep (line 301) | def start_sweep(self):
    method abort (line 309) | def abort(self):
    method clear (line 313) | def clear(self):
    method query (line 317) | def query(self, cmd, size=-1):

FILE: src/instruments/yokogawa/yokogawa7651.py
  class Yokogawa7651 (line 20) | class Yokogawa7651(PowerSupply, Instrument):
    class Channel (line 34) | class Channel(PowerSupply.Channel):
      method __init__ (line 44) | def __init__(self, parent, name):
      method mode (line 51) | def mode(self):
      method mode (line 65) | def mode(self, newval):
      method voltage (line 75) | def voltage(self):
      method voltage (line 92) | def voltage(self, newval):
      method current (line 99) | def current(self):
      method current (line 116) | def current(self, newval):
      method output (line 123) | def output(self):
      method output (line 137) | def output(self, newval):
    class Mode (line 147) | class Mode(IntEnum):
    method channel (line 158) | def channel(self):
    method voltage (line 175) | def voltage(self):
    method voltage (line 190) | def voltage(self, newval):
    method current (line 194) | def current(self):
    method current (line 209) | def current(self, newval):
    method trigger (line 214) | def trigger(self):

FILE: tests/__init__.py
  function expected_protocol (line 25) | def expected_protocol(ins_class, host_to_ins, ins_to_host, sep="\n", rep...
  function unit_eq (line 104) | def unit_eq(a, b, **kwargs):
  function make_name_test (line 119) | def make_name_test(ins_class, name_cmd="*IDN?"):
  function iterable_eq (line 132) | def iterable_eq(a, b, **kwargs):

FILE: tests/test_abstract_inst/test_electrometer.py
  function em (line 18) | def em(monkeypatch):
  function test_electrometer_mode (line 25) | def test_electrometer_mode(em):
  function test_electrometer_unit (line 32) | def test_electrometer_unit(em):
  function test_electrometer_trigger_mode (line 38) | def test_electrometer_trigger_mode(em):
  function test_electrometer_input_range (line 45) | def test_electrometer_input_range(em):
  function test_electrometer_zero_check (line 52) | def test_electrometer_zero_check(em):
  function test_electrometer_zero_correct (line 59) | def test_electrometer_zero_correct(em):
  function test_electrometer_fetch (line 66) | def test_electrometer_fetch(em):
  function test_electrometer_read_measurements (line 73) | def test_electrometer_read_measurements(em):

FILE: tests/test_abstract_inst/test_function_generator.py
  function fg (line 21) | def fg():
  function test_func_gen_default_channel_count (line 25) | def test_func_gen_default_channel_count(fg):
  function test_func_gen_raises_not_implemented_error_one_channel_getting (line 29) | def test_func_gen_raises_not_implemented_error_one_channel_getting(fg):
  function test_func_gen_raises_not_implemented_error_one_channel_setting (line 43) | def test_func_gen_raises_not_implemented_error_one_channel_setting(fg):
  function test_func_gen_raises_not_implemented_error_two_channel_getting (line 57) | def test_func_gen_raises_not_implemented_error_two_channel_getting(fg):
  function test_func_gen_raises_not_implemented_error_two_channel_setting (line 71) | def test_func_gen_raises_not_implemented_error_two_channel_setting(fg):
  function test_func_gen_two_channel_passes_thru_call_getter (line 85) | def test_func_gen_two_channel_passes_thru_call_getter(fg, mocker):
  function test_func_gen_one_channel_passes_thru_call_getter (line 109) | def test_func_gen_one_channel_passes_thru_call_getter(fg, mocker):
  function test_func_gen_two_channel_passes_thru_call_setter (line 147) | def test_func_gen_two_channel_passes_thru_call_setter(fg, mocker):
  function test_func_gen_one_channel_passes_thru_call_setter (line 171) | def test_func_gen_one_channel_passes_thru_call_setter(fg, mocker):
  function test_func_gen_channel_set_amplitude_dbm (line 209) | def test_func_gen_channel_set_amplitude_dbm(mocker):
  function test_func_gen_channel_sendcmd (line 227) | def test_func_gen_channel_sendcmd(mocker):
  function test_func_gen__channel_sendcmd (line 238) | def test_func_gen__channel_sendcmd(mocker):

FILE: tests/test_abstract_inst/test_multimeter.py
  function mul (line 18) | def mul(monkeypatch):
  function test_multimeter_mode (line 25) | def test_multimeter_mode(mul):
  function test_multimeter_trigger_mode (line 32) | def test_multimeter_trigger_mode(mul):
  function test_multimeter_relative (line 39) | def test_multimeter_relative(mul):
  function test_multimeter_input_range (line 46) | def test_multimeter_input_range(mul):
  function test_multimeter_measure (line 53) | def test_multimeter_measure(mul):

FILE: tests/test_abstract_inst/test_optical_spectrum_analyzer.py
  function osa (line 18) | def osa(monkeypatch):
  function test_osa_channel (line 30) | def test_osa_channel(osa):
  function test_osa_start_wl (line 37) | def test_osa_start_wl(osa):
  function test_osa_stop_wl (line 46) | def test_osa_stop_wl(osa):
  function test_osa_bandwidth (line 55) | def test_osa_bandwidth(osa):
  function test_osa_start_sweep (line 64) | def test_osa_start_sweep(osa):
  function test_osa_channel_wavelength (line 75) | def test_osa_channel_wavelength(osa, num_ch):
  function test_osa_channel_data (line 87) | def test_osa_channel_data(osa, num_ch):

FILE: tests/test_abstract_inst/test_oscilloscope.py
  function osc (line 18) | def osc(monkeypatch):
  function osc_ch (line 26) | def osc_ch(monkeypatch):
  function osc_ds (line 34) | def osc_ds(monkeypatch):
  function test_oscilloscope_channel (line 44) | def test_oscilloscope_channel(osc):
  function test_oscilloscope_ref (line 51) | def test_oscilloscope_ref(osc):
  function test_oscilloscope_math (line 58) | def test_oscilloscope_math(osc):
  function test_oscilloscope_force_trigger (line 65) | def test_oscilloscope_force_trigger(osc):
  function test_oscilloscope_channel_coupling (line 75) | def test_oscilloscope_channel_coupling(osc_ch):
  function test_oscilloscope_data_source_init (line 87) | def test_oscilloscope_data_source_init(osc_ds):
  function test_oscilloscope_data_source_name (line 97) | def test_oscilloscope_data_source_name(osc_ds):
  function test_oscilloscope_data_source_read_waveform (line 106) | def test_oscilloscope_data_source_read_waveform(osc_ds):

FILE: tests/test_abstract_inst/test_power_supply.py
  function ps (line 18) | def ps(monkeypatch):
  function ps_ch (line 26) | def ps_ch(monkeypatch):
  function test_power_supply_channel (line 36) | def test_power_supply_channel(ps):
  function test_power_supply_voltage (line 43) | def test_power_supply_voltage(ps):
  function test_power_supply_current (line 50) | def test_power_supply_current(ps):
  function test_power_supply_channel_mode (line 60) | def test_power_supply_channel_mode(ps_ch):
  function test_power_supply_channel_voltage (line 67) | def test_power_supply_channel_voltage(ps_ch):
  function test_power_supply_channel_current (line 74) | def test_power_supply_channel_current(ps_ch):
  function test_power_supply_channel_output (line 81) | def test_power_supply_channel_output(ps_ch):

FILE: tests/test_abstract_inst/test_signal_generator/test_channel.py
  function sgc (line 17) | def sgc(monkeypatch):
  function test_sg_channel_frequency (line 24) | def test_sg_channel_frequency(sgc):
  function test_sg_channel_power (line 31) | def test_sg_channel_power(sgc):
  function test_sg_channel_phase (line 38) | def test_sg_channel_phase(sgc):
  function test_sg_channel_output (line 45) | def test_sg_channel_output(sgc):

FILE: tests/test_abstract_inst/test_signal_generator/test_signal_generator.py
  function sg (line 18) | def sg(monkeypatch):
  function test_signal_generator_channel (line 25) | def test_signal_generator_channel(sg):

FILE: tests/test_abstract_inst/test_signal_generator/test_single_channel_sg.py
  function scsg (line 18) | def scsg(monkeypatch):
  function test_signal_generator_channel (line 25) | def test_signal_generator_channel(scsg):

FILE: tests/test_agilent/test_agilent_33220a.py
  function test_agilent33220a_amplitude (line 21) | def test_agilent33220a_amplitude():
  function test_agilent33220a_frequency (line 39) | def test_agilent33220a_frequency():
  function test_agilent33220a_function (line 47) | def test_agilent33220a_function():
  function test_agilent33220a_offset (line 55) | def test_agilent33220a_offset():
  function test_agilent33220a_duty_cycle (line 67) | def test_agilent33220a_duty_cycle():
  function test_agilent33220a_ramp_symmetry (line 79) | def test_agilent33220a_ramp_symmetry():
  function test_agilent33220a_output (line 91) | def test_agilent33220a_output():
  function test_agilent33220a_output_sync (line 103) | def test_agilent33220a_output_sync():
  function test_agilent33220a_output_polarity (line 115) | def test_agilent33220a_output_polarity():
  function test_agilent33220a_load_resistance (line 127) | def test_agilent33220a_load_resistance():
  function test_agilent33220a_load_resistance_value_invalid (line 140) | def test_agilent33220a_load_resistance_value_invalid(value):
  function test_phase_not_implemented_error (line 149) | def test_phase_not_implemented_error():

FILE: tests/test_agilent/test_agilent_34410a.py
  function test_agilent34410a_read (line 20) | def test_agilent34410a_read():
  function test_agilent34410a_data_point_count (line 29) | def test_agilent34410a_data_point_count():
  function test_agilent34410a_init (line 42) | def test_agilent34410a_init():
  function test_agilent34410a_abort (line 48) | def test_agilent34410a_abort():
  function test_agilent34410a_clear_memory (line 54) | def test_agilent34410a_clear_memory():
  function test_agilent34410a_r (line 60) | def test_agilent34410a_r():
  function test_agilent34410a_r_count_zero (line 77) | def test_agilent34410a_r_count_zero():
  function test_agilent34410a_r_type_error (line 95) | def test_agilent34410a_r_type_error():
  function test_agilent34410a_fetch (line 113) | def test_agilent34410a_fetch():
  function test_agilent34410a_read_data (line 126) | def test_agilent34410a_read_data():
  function test_agilent34410a_read_data_count_minus_one (line 137) | def test_agilent34410a_read_data_count_minus_one():
  function test_agilent34410a_read_data_type_error (line 154) | def test_agilent34410a_read_data_type_error():
  function test_agilent34410a_read_data_nvmem (line 164) | def test_agilent34410a_read_data_nvmem():
  function test_agilent34410a_read_last_data (line 178) | def test_agilent34410a_read_last_data():
  function test_agilent34410a_read_last_data_na (line 191) | def test_agilent34410a_read_last_data_na():

FILE: tests/test_aimtti/test_aimttiel302p.py
  function test_channel (line 17) | def test_channel():
  function test_current (line 23) | def test_current():
  function test_current_sense (line 31) | def test_current_sense():
  function test_error (line 38) | def test_error():
  function test_mode (line 45) | def test_mode():
  function test_name (line 50) | def test_name():
  function test_off (line 57) | def test_off():
  function test_on (line 65) | def test_on():
  function test_reset (line 73) | def test_reset():
  function test_voltage (line 78) | def test_voltage():
  function test_voltage_sense (line 86) | def test_voltage_sense():

FILE: tests/test_base_instrument.py
  function test_instrument_binblockread (line 47) | def test_instrument_binblockread():
  function test_instrument_binblockread_two_reads (line 63) | def test_instrument_binblockread_two_reads():
  function test_instrument_binblockread_too_many_reads (line 80) | def test_instrument_binblockread_too_many_reads():
  function test_instrument_binblockread_bad_block_start (line 91) | def test_instrument_binblockread_bad_block_start():
  function test_instrument_open_tcpip (line 104) | def test_instrument_open_tcpip(mock_socket, mock_socket_comm):
  function test_instrument_open_tcpip_auth_not_implemented (line 116) | def test_instrument_open_tcpip_auth_not_implemented():
  function test_instrument_open_tcpip_passing_on_auth (line 126) | def test_instrument_open_tcpip_passing_on_auth(
  function test_instrument_open_serial (line 148) | def test_instrument_open_serial(mock_serial_manager):
  class fake_serial (line 162) | class fake_serial:
    method __init__ (line 169) | def __init__(self, device, baudrate=None, timeout=None, writeTimeout=N...
    method isOpen (line 172) | def isOpen(self):
  function fake_comports (line 182) | def fake_comports():
  function test_instrument_open_serial_by_usb_ids (line 200) | def test_instrument_open_serial_by_usb_ids(mock_serial_manager):
  function test_instrument_open_serial_by_usb_ids_and_serial_number (line 214) | def test_instrument_open_serial_by_usb_ids_and_serial_number(mock_serial...
  function test_instrument_open_serial_by_usb_ids_multiple_matches (line 228) | def test_instrument_open_serial_by_usb_ids_multiple_matches(_, mock_comp...
  function test_instrument_open_serial_by_usb_ids_incorrect_serial_num (line 247) | def test_instrument_open_serial_by_usb_ids_incorrect_serial_num(mock_ser...
  function test_instrument_open_serial_by_usb_ids_cant_find (line 257) | def test_instrument_open_serial_by_usb_ids_cant_find(mock_serial_manager):
  function test_instrument_open_serial_no_port (line 267) | def test_instrument_open_serial_no_port(mock_serial_manager):
  function test_instrument_open_serial_by_usb_ids_and_port (line 277) | def test_instrument_open_serial_by_usb_ids_and_port(mock_serial_manager):
  function test_instrument_open_serial_by_usb_vid_no_pid (line 287) | def test_instrument_open_serial_by_usb_vid_no_pid(mock_serial_manager):
  function test_instrument_open_serial_by_usb_pid_no_vid (line 297) | def test_instrument_open_serial_by_usb_pid_no_vid(mock_serial_manager):
  function test_instrument_open_gpibusb (line 310) | def test_instrument_open_gpibusb(mock_serial_manager, mock_gpib_comm):
  function test_instrument_open_gpibethernet (line 331) | def test_instrument_open_gpibethernet(mock_socket_manager, mock_gpib_comm):
  function test_instrument_open_visa_new_version (line 346) | def test_instrument_open_visa_new_version(mock_visa, mock_visa_comm):
  function test_instrument_open_visa_old_version (line 361) | def test_instrument_open_visa_old_version(mock_visa, mock_visa_comm):
  function test_instrument_open_test (line 372) | def test_instrument_open_test():
  function test_instrument_open_vxi11 (line 386) | def test_instrument_open_vxi11(mock_vxi11_comm):
  function test_instrument_open_usb (line 398) | def test_instrument_open_usb(mock_usb, mock_usb_comm):
  function test_instrument_open_usb_no_device (line 416) | def test_instrument_open_usb_no_device(mock_usb):
  function test_instrument_open_usbtmc (line 426) | def test_instrument_open_usbtmc(mock_usbtmc_comm):
  function test_instrument_open_file (line 437) | def test_instrument_open_file(mock_file_comm):
  function test_instrument_open_from_uri_serial (line 451) | def test_instrument_open_from_uri_serial(mock_open_conn):
  function test_instrument_open_from_uri_serial_with_baud (line 458) | def test_instrument_open_from_uri_serial_with_baud(mock_open_conn):
  function test_instrument_open_from_uri_tcpip (line 465) | def test_instrument_open_from_uri_tcpip(mock_open_conn):
  function test_instrument_open_from_uri_gpibusb (line 472) | def test_instrument_open_from_uri_gpibusb(mock_open_conn):
  function test_instrument_open_from_uri_gpibserial (line 479) | def test_instrument_open_from_uri_gpibserial(mock_open_conn):
  function test_instrument_open_from_uri_visa (line 486) | def test_instrument_open_from_uri_visa(mock_open_conn):
  function test_instrument_open_from_uri_usbtmc (line 493) | def test_instrument_open_from_uri_usbtmc(mock_open_conn):
  function test_instrument_open_from_uri_file (line 500) | def test_instrument_open_from_uri_file(mock_open_conn):
  function test_instrument_open_from_uri_vxi11 (line 507) | def test_instrument_open_from_uri_vxi11(mock_open_conn):
  function test_instrument_open_from_uri_invalid_scheme (line 513) | def test_instrument_open_from_uri_invalid_scheme():
  function test_instrument_context_manager (line 519) | def test_instrument_context_manager(mock_close: mock.Mock):
  function test_instrument_init_bad_filelike (line 528) | def test_instrument_init_bad_filelike():
  function test_instrument_init (line 533) | def test_instrument_init():
  function test_instrument_init_loopbackcomm (line 544) | def test_instrument_init_loopbackcomm():
  function test_instrument_default_ack_expected (line 555) | def test_instrument_default_ack_expected():
  function test_instrument_sendcmd_noack_noprompt (line 564) | def test_instrument_sendcmd_noack_noprompt():
  function test_instrument_sendcmd_noprompt (line 574) | def test_instrument_sendcmd_noprompt():
  function test_instrument_sendcmd_noprompt_multiple_ack (line 590) | def test_instrument_sendcmd_noprompt_multiple_ack():
  function test_instrument_sendcmd_bad_ack (line 606) | def test_instrument_sendcmd_bad_ack():
  function test_instrument_sendcmd_noack (line 621) | def test_instrument_sendcmd_noack():
  function test_instrument_sendcmd_noack_bad_prompt (line 634) | def test_instrument_sendcmd_noack_bad_prompt():
  function test_instrument_sendcmd (line 646) | def test_instrument_sendcmd():
  function test_instrument_query_noack_noprompt (line 665) | def test_instrument_query_noack_noprompt():
  function test_instrument_query_noprompt (line 676) | def test_instrument_query_noprompt():
  function test_instrument_query_noprompt_multiple_ack (line 700) | def test_instrument_query_noprompt_multiple_ack():
  function test_instrument_query_bad_ack (line 725) | def test_instrument_query_bad_ack():
  function test_instrument_query_noack (line 740) | def test_instrument_query_noack():
  function test_instrument_query_noack_bad_prompt (line 762) | def test_instrument_query_noack_bad_prompt():
  function test_instrument_query (line 775) | def test_instrument_query():
  function test_instrument_read (line 806) | def test_instrument_read():
  function test_instrument_write (line 822) | def test_instrument_write():
  function test_instrument_timeout (line 834) | def test_instrument_timeout():
  function test_instrument_address (line 848) | def test_instrument_address():
  function test_instrument_terminator (line 862) | def test_instrument_terminator():
  function test_instrument_prompt (line 876) | def test_instrument_prompt():

FILE: tests/test_comet/test_cito_plus_1310.py
  function add_checksum (line 13) | def add_checksum(data: bytes) -> bytes:
  function test_name (line 22) | def test_name():
  function test_forward_power (line 41) | def test_forward_power():
  function test_load_power (line 56) | def test_load_power():
  function test_output_power (line 71) | def test_output_power():
  function test_output_power_smaller_one (line 96) | def test_output_power_smaller_one(pow):
  function test_reflected_power (line 109) | def test_reflected_power():
  function test_regulation_mode (line 124) | def test_regulation_mode():
  function test_rf (line 159) | def test_rf():
  function test_checksum_error_return_package (line 193) | def test_checksum_error_return_package():
  function test_unknown_parameter (line 210) | def test_unknown_parameter():
  function test_write_answer_package_no_match (line 227) | def test_write_answer_package_no_match():
  function test_crc16 (line 251) | def test_crc16(inp_out):

FILE: tests/test_comm/test_file.py
  function test_filecomm_init (line 21) | def test_filecomm_init():
  function test_filecomm_address_getter (line 27) | def test_filecomm_address_getter():
  function test_filecomm_address_getter_no_name (line 38) | def test_filecomm_address_getter_no_name():
  function test_filecomm_address_setter (line 47) | def test_filecomm_address_setter():
  function test_filecomm_terminator (line 53) | def test_filecomm_terminator():
  function test_filecomm_timeout_getter (line 65) | def test_filecomm_timeout_getter():
  function test_filecomm_timeout_setter (line 71) | def test_filecomm_timeout_setter():
  function test_filecomm_close (line 77) | def test_filecomm_close():
  function test_filecomm_read_raw (line 84) | def test_filecomm_read_raw():
  function test_filecomm_write_raw (line 97) | def test_filecomm_write_raw():
  function test_filecomm_sendcmd (line 104) | def test_filecomm_sendcmd():
  function test_filecomm_query (line 111) | def test_filecomm_query():
  function test_filecomm_seek (line 119) | def test_filecomm_seek():
  function test_filecomm_tell (line 125) | def test_filecomm_tell():
  function test_filecomm_flush_input (line 133) | def test_filecomm_flush_input():

FILE: tests/test_comm/test_gpibusb.py
  function test_gpibusbcomm_init (line 22) | def test_gpibusbcomm_init():
  function test_gpibusbcomm_init_correct_values_new_firmware (line 30) | def test_gpibusbcomm_init_correct_values_new_firmware():
  function test_gpibusbcomm_init_correct_values_old_firmware (line 42) | def test_gpibusbcomm_init_correct_values_old_firmware():
  function test_gpibusbcomm_address (line 51) | def test_gpibusbcomm_address():
  function test_gpibusbcomm_address_out_of_range (line 72) | def test_gpibusbcomm_address_out_of_range():
  function test_gpibusbcomm_address_wrong_type (line 79) | def test_gpibusbcomm_address_wrong_type():
  function test_gpibusbcomm_eoi (line 85) | def test_gpibusbcomm_eoi():
  function test_gpibusbcomm_eoi_old_firmware (line 102) | def test_gpibusbcomm_eoi_old_firmware():
  function test_gpibusbcomm_eoi_bad_type (line 119) | def test_gpibusbcomm_eoi_bad_type():
  function test_gpibusbcomm_eos_rn (line 126) | def test_gpibusbcomm_eos_rn():
  function test_gpibusbcomm_eos_r (line 137) | def test_gpibusbcomm_eos_r():
  function test_gpibusbcomm_eos_n (line 148) | def test_gpibusbcomm_eos_n():
  function test_gpibusbcomm_eos_invalid (line 159) | def test_gpibusbcomm_eos_invalid():
  function test_gpibusbcomm_eos_old_firmware (line 166) | def test_gpibusbcomm_eos_old_firmware():
  function test_gpibusbcomm_terminator (line 176) | def test_gpibusbcomm_terminator():
  function test_gpibusbcomm_timeout (line 193) | def test_gpibusbcomm_timeout():
  function test_gpibusbcomm_close (line 203) | def test_gpibusbcomm_close():
  function test_gpibusbcomm_read_raw (line 211) | def test_gpibusbcomm_read_raw():
  function test_gpibusbcomm_write_raw (line 220) | def test_gpibusbcomm_write_raw():
  function test_gpibusbcomm_sendcmd (line 228) | def test_gpibusbcomm_sendcmd():
  function test_gpibusbcomm_sendcmd_empty_string (line 244) | def test_gpibusbcomm_sendcmd_empty_string():
  function test_gpibusbcomm_query (line 253) | def test_gpibusbcomm_query():
  function test_gpibusbcomm_query_no_question_mark (line 268) | def test_gpibusbcomm_query_no_question_mark():
  function test_serialcomm_flush_input (line 282) | def test_serialcomm_flush_input():

FILE: tests/test_comm/test_loopback.py
  function test_loopbackcomm_init (line 19) | def test_loopbackcomm_init():
  function test_loopbackcomm_address (line 28) | def test_loopbackcomm_address(mock_sys):
  function test_loopbackcomm_terminator (line 39) | def test_loopbackcomm_terminator():
  function test_loopbackcomm_timeout (line 58) | def test_loopbackcomm_timeout():
  function test_loopbackcomm_close (line 67) | def test_loopbackcomm_close():
  function test_loopbackcomm_read_raw (line 75) | def test_loopbackcomm_read_raw():
  function test_loopbackcomm_read_raw_2char_terminator (line 89) | def test_loopbackcomm_read_raw_2char_terminator():
  function test_loopbackcomm_read_raw_terminator_is_empty_string (line 100) | def test_loopbackcomm_read_raw_terminator_is_empty_string():
  function test_loopbackcomm_read_raw_size_invalid (line 111) | def test_loopbackcomm_read_raw_size_invalid():
  function test_loopbackcomm_read_raw_stdin (line 120) | def test_loopbackcomm_read_raw_stdin(mock_input):
  function test_loopbackcomm_write_raw (line 126) | def test_loopbackcomm_write_raw():
  function test_loopbackcomm_sendcmd (line 133) | def test_loopbackcomm_sendcmd():
  function test_loopbackcomm_query (line 145) | def test_loopbackcomm_query():
  function test_loopbackcomm_seek (line 158) | def test_loopbackcomm_seek():
  function test_loopbackcomm_tell (line 164) | def test_loopbackcomm_tell():
  function test_loopbackcomm_flush_input (line 170) | def test_loopbackcomm_flush_input():

FILE: tests/test_comm/test_serial.py
  function test_serialcomm_init (line 22) | def test_serialcomm_init():
  function test_serialcomm_init_wrong_filelike (line 27) | def test_serialcomm_init_wrong_filelike():
  function test_serialcomm_address (line 32) | def test_serialcomm_address():
  function test_serialcomm_terminator (line 45) | def test_serialcomm_terminator():
  function test_serialcomm_timeout (line 59) | def test_serialcomm_timeout():
  function test_serialcomm_parity (line 76) | def test_serialcomm_parity():
  function test_serialcomm_close (line 86) | def test_serialcomm_close():
  function test_serialcomm_read_raw (line 95) | def test_serialcomm_read_raw():
  function test_loopbackcomm_read_raw_2char_terminator (line 109) | def test_loopbackcomm_read_raw_2char_terminator():
  function test_serialcomm_read_raw_timeout (line 120) | def test_serialcomm_read_raw_timeout():
  function test_serialcomm_write_raw (line 129) | def test_serialcomm_write_raw():
  function test_serialcomm_sendcmd (line 137) | def test_serialcomm_sendcmd():
  function test_serialcomm_query (line 145) | def test_serialcomm_query():
  function test_serialcomm_seek (line 159) | def test_serialcomm_seek():
  function test_serialcomm_tell (line 165) | def test_serialcomm_tell():
  function test_serialcomm_flush_input (line 171) | def test_serialcomm_flush_input():

FILE: tests/test_comm/test_socket.py
  function test_socketcomm_init (line 23) | def test_socketcomm_init():
  function test_socketcomm_init_wrong_filelike (line 30) | def test_socketcomm_init_wrong_filelike():
  function test_socketcomm_address (line 35) | def test_socketcomm_address():
  function test_socketcomm_address_setting (line 44) | def test_socketcomm_address_setting():
  function test_socketcomm_terminator (line 50) | def test_socketcomm_terminator():
  function test_socketcomm_timeout (line 69) | def test_socketcomm_timeout():
  function test_socketcomm_close (line 84) | def test_socketcomm_close():
  function test_socketcomm_read_raw (line 93) | def test_socketcomm_read_raw():
  function test_loopbackcomm_read_raw_2char_terminator (line 107) | def test_loopbackcomm_read_raw_2char_terminator():
  function test_serialcomm_read_raw_timeout (line 118) | def test_serialcomm_read_raw_timeout():
  function test_socketcomm_write_raw (line 127) | def test_socketcomm_write_raw():
  function test_socketcomm_sendcmd (line 135) | def test_socketcomm_sendcmd():
  function test_socketcomm_query (line 143) | def test_socketcomm_query():
  function test_socketcomm_seek (line 157) | def test_socketcomm_seek():
  function test_socketcomm_tell (line 163) | def test_socketcomm_tell():
  function test_socketcomm_flush_input (line 169) | def test_socketcomm_flush_input():

FILE: tests/test_comm/test_usb_communicator.py
  function dev (line 27) | def dev():
  function inst (line 36) | def inst(patch_util, dev):
  function test_init (line 42) | def test_init(usb_util, dev):
  function test_init_wrong_type (line 64) | def test_init_wrong_type():
  function test_init_no_endpoints (line 72) | def test_init_no_endpoints(dev):
  function test_address (line 83) | def test_address(inst):
  function test_terminator (line 95) | def test_terminator(inst):
  function test_terminator_wrong_type (line 102) | def test_terminator_wrong_type(inst):
  function test_timeout_get (line 114) | def test_timeout_get(val, inst):
  function test_timeout_set_unitless (line 123) | def test_timeout_set_unitless(inst):
  function test_timeout_set_minutes (line 132) | def test_timeout_set_minutes(inst):
  function test_close (line 143) | def test_close(usb_util, inst):
  function test_read_raw (line 150) | def test_read_raw(inst):
  function test_read_raw_size (line 160) | def test_read_raw_size(inst):
  function test_read_raw_termination_char_not_found (line 173) | def test_read_raw_termination_char_not_found(inst):
  function test_write_raw (line 191) | def test_write_raw(inst):
  function test_seek (line 198) | def test_seek(inst):
  function test_tell (line 204) | def test_tell(inst):
  function test_flush_input (line 210) | def test_flush_input(inst):
  function test_sendcmd (line 217) | def test_sendcmd(inst):
  function test_query (line 228) | def test_query(inst):

FILE: tests/test_comm/test_usbtmc.py
  function test_usbtmccomm_init (line 24) | def test_usbtmccomm_init(mock_usbtmc):
  function test_usbtmccomm_init_missing_module (line 30) | def test_usbtmccomm_init_missing_module():
  function test_usbtmccomm_terminator_getter (line 36) | def test_usbtmccomm_terminator_getter(mock_usbtmc):
  function test_usbtmccomm_terminator_setter (line 47) | def test_usbtmccomm_terminator_setter(mock_usbtmc):
  function test_usbtmccomm_timeout (line 63) | def test_usbtmccomm_timeout(mock_usbtmc):
  function test_usbtmccomm_close (line 80) | def test_usbtmccomm_close(mock_usbtmc):
  function test_usbtmccomm_read_raw (line 88) | def test_usbtmccomm_read_raw(mock_usbtmc):
  function test_usbtmccomm_write_raw (line 102) | def test_usbtmccomm_write_raw(mock_usbtmc):
  function test_usbtmccomm_sendcmd (line 110) | def test_usbtmccomm_sendcmd(mock_usbtmc):
  function test_usbtmccomm_query (line 119) | def test_usbtmccomm_query(mock_usbtmc):
  function test_usbtmccomm_seek (line 131) | def test_usbtmccomm_seek(mock_usbtmc):
  function test_usbtmccomm_tell (line 138) | def test_usbtmccomm_tell(mock_usbtmc):
  function test_usbtmccomm_flush_input (line 145) | def test_usbtmccomm_flush_input(mock_usbtmc):

FILE: tests/test_comm/test_visa_communicator.py
  function visa_inst (line 22) | def visa_inst():
  function test_visacomm_init (line 28) | def test_visacomm_init(visa_inst):
  function test_visacomm_init_wrong_type (line 36) | def test_visacomm_init_wrong_type():
  function test_visacomm_address (line 44) | def test_visacomm_address(visa_inst):
  function test_visacomm_read_termination_not_string (line 54) | def test_visacomm_read_termination_not_string(visa_inst):
  function test_visacomm_terminator (line 61) | def test_visacomm_terminator(visa_inst):
  function test_visacomm_terminator_not_string (line 71) | def test_visacomm_terminator_not_string(visa_inst):
  function test_visacomm_timeout (line 80) | def test_visacomm_timeout(visa_inst):
  function test_visacomm_write_termination_not_string (line 89) | def test_visacomm_write_termination_not_string(visa_inst):
  function test_visacomm_close (line 96) | def test_visacomm_close(visa_inst, mocker):
  function test_visacomm_read_raw (line 106) | def test_visacomm_read_raw(visa_inst, mocker):
  function test_visacomm_read_raw_size (line 115) | def test_visacomm_read_raw_size(visa_inst, mocker):
  function test_visacomm_read_raw_wrong_size (line 126) | def test_visacomm_read_raw_wrong_size(visa_inst):
  function test_visacomm_write_raw (line 137) | def test_visacomm_write_raw(visa_inst, mocker):
  function test_visacomm_seek_not_implemented (line 146) | def test_visacomm_seek_not_implemented(visa_inst):
  function test_visacomm_tell_not_implemented (line 153) | def test_visacomm_tell_not_implemented(visa_inst):
  function test_visacomm_sendcmd (line 160) | def test_visacomm_sendcmd(visa_inst, mocker):
  function test_visacomm_query (line 169) | def test_visacomm_query(visa_inst, mocker):

FILE: tests/test_comm/test_vxi11.py
  function test_vxi11comm_init (line 22) | def test_vxi11comm_init(mock_vxi11):
  function test_vxi11comm_init_no_vxi11 (line 28) | def test_vxi11comm_init_no_vxi11():
  function test_vxi11comm_address (line 34) | def test_vxi11comm_address(mock_vxi11):
  function test_vxi11comm_terminator (line 52) | def test_vxi11comm_terminator(mock_vxi11):
  function test_vxi11comm_timeout (line 66) | def test_vxi11comm_timeout(mock_vxi11):
  function test_vxi11comm_close (line 80) | def test_vxi11comm_close(mock_vxi11):
  function test_vxi11comm_close_fail (line 88) | def test_vxi11comm_close_fail(mock_vxi11):
  function test_vxi11comm_read (line 97) | def test_vxi11comm_read(mock_vxi11):
  function test_vxi11comm_write (line 109) | def test_vxi11comm_write(mock_vxi11):
  function test_vxi11comm_sendcmd (line 117) | def test_vxi11comm_sendcmd(mock_vxi11):
  function test_vxi11comm_query (line 125) | def test_vxi11comm_query(mock_vxi11):
  function test_vxi11comm_seek (line 137) | def test_vxi11comm_seek(mock_vxi11):
  function test_vxi11comm_tell (line 144) | def test_vxi11comm_tell(mock_vxi11):
  function test_vxi11comm_flush (line 151) | def test_vxi11comm_flush(mock_vxi11):

FILE: tests/test_config.py
  function test_load_test_instrument (line 24) | def test_load_test_instrument():
  function test_load_test_instrument_from_file (line 34) | def test_load_test_instrument_from_file(tmp_path):
  function test_load_test_instrument_subtree (line 46) | def test_load_test_instrument_subtree():
  function test_yaml_quantity_tag (line 57) | def test_yaml_quantity_tag():
  function test_load_test_instrument_setattr (line 70) | def test_load_test_instrument_setattr():
  function test_load_test_instrument_oserror (line 82) | def test_load_test_instrument_oserror(mocker):

FILE: tests/test_delta_elektronika/test_psc_eth.py
  function test_current_limit (line 17) | def test_current_limit():
  function test_voltage_limit (line 34) | def test_voltage_limit():
  function test_current (line 51) | def test_current():
  function test_current_max (line 64) | def test_current_max():
  function test_current_measure (line 77) | def test_current_measure():
  function test_current_stepsize (line 89) | def test_current_stepsize():
  function test_voltage (line 101) | def test_voltage():
  function test_voltage_max (line 114) | def test_voltage_max():
  function test_voltage_measure (line 127) | def test_voltage_measure():
  function test_voltage_stepsize (line 139) | def test_voltage_stepsize():
  function test_recall (line 154) | def test_recall():
  function test_reset (line 165) | def test_reset():
  function test_save (line 176) | def test_save():
  function test_set_current_limit (line 187) | def test_set_current_limit():
  function test_set_current_limit_invalid_type (line 199) | def test_set_current_limit_invalid_type():
  function test_set_voltage_limit (line 211) | def test_set_voltage_limit():
  function test_set_voltage_limit_invalid_type (line 223) | def test_set_voltage_limit_invalid_type():

FILE: tests/test_dressler/test_cesar_1312.py
  function test_address (line 21) | def test_address():
  function test_retries (line 38) | def test_retries():
  function test_control_mode (line 57) | def test_control_mode():
  function test_name (line 89) | def test_name():
  function test_output_power (line 118) | def test_output_power():
  function test_regulation_mode (line 149) | def test_regulation_mode():
  function test_reflected_power (line 181) | def test_reflected_power():
  function test_rf (line 197) | def test_rf():
  function test_rf_cmd_invalid (line 236) | def test_rf_cmd_invalid():
  function test_rf_reply_invalid (line 256) | def test_rf_reply_invalid():
  function test_unknown_command (line 280) | def test_unknown_command():
  function test_device_returns_no_data (line 301) | def test_device_returns_no_data():
  function test_answer_longer_six_bytes (line 322) | def test_answer_longer_six_bytes():
  function test_make_pkg (line 353) | def test_make_pkg():
  function test_make_pkg_error (line 405) | def test_make_pkg_error():
  function test_checksum (line 421) | def test_checksum(values):
  function test_pack_header (line 440) | def test_pack_header(addr, data_length):
  function test_unpack_header (line 456) | def test_unpack_header(hdr_int):
  function checksum (line 470) | def checksum(values: bytes) -> bytes:

FILE: tests/test_fluke/test_fluke3000.py
  function test_mode (line 86) | def test_mode():
  function test_mode_key_error (line 101) | def test_mode_key_error():
  function test_trigger_mode_attribute_error (line 114) | def test_trigger_mode_attribute_error():
  function test_relative_attribute_error (line 125) | def test_relative_attribute_error():
  function test_input_range_attribute_error (line 136) | def test_input_range_attribute_error():
  function test_connect (line 150) | def test_connect():
  function test_connect_no_modules_available (line 178) | def test_connect_no_modules_available():
  function test_scan (line 189) | def test_scan():
  function test_scan_module_not_implemented (line 197) | def test_scan_module_not_implemented():
  function test_reset (line 212) | def test_reset():
  function test_flush (line 229) | def test_flush(mocker):
  function test_measure (line 246) | def test_measure():
  function test_measure_invalid_mode (line 264) | def test_measure_invalid_mode():
  function test_measure_no_module_with_mode (line 276) | def test_measure_no_module_with_mode():
  function test_measure_inconsistent_answer (line 294) | def test_measure_inconsistent_answer(mocker):
  function test_parse_ph_not_in_result (line 337) | def test_parse_ph_not_in_result():
  function test_parse_wrong_mode (line 352) | def test_parse_wrong_mode():
  function test_parse_factor_wrong_code (line 371) | def test_parse_factor_wrong_code():

FILE: tests/test_generic_scpi/test_scpi_function_generator.py
  function test_scpi_func_gen_amplitude (line 20) | def test_scpi_func_gen_amplitude():
  function test_scpi_func_gen_frequency (line 43) | def test_scpi_func_gen_frequency():
  function test_scpi_func_gen_function (line 57) | def test_scpi_func_gen_function():
  function test_scpi_func_gen_offset (line 68) | def test_scpi_func_gen_offset():
  function test_scpi_func_gen_phase (line 84) | def test_scpi_func_gen_phase():

FILE: tests/test_generic_scpi/test_scpi_instrument.py
  function test_scpi_instrument_scpi_version (line 22) | def test_scpi_instrument_scpi_version():
  function test_scpi_instrument_op_complete (line 32) | def test_scpi_instrument_op_complete(retval):
  function test_scpi_instrument_power_on_status_off (line 41) | def test_scpi_instrument_power_on_status_off(retval):
  function test_scpi_instrument_power_on_status_on (line 51) | def test_scpi_instrument_power_on_status_on(retval):
  function test_scpi_instrument_power_on_status_value_error (line 60) | def test_scpi_instrument_power_on_status_value_error():
  function test_scpi_instrument_self_test_ok (line 67) | def test_scpi_instrument_self_test_ok():
  function test_scpi_instrument_reset (line 76) | def test_scpi_instrument_reset():
  function test_scpi_instrument_clear (line 82) | def test_scpi_instrument_clear():
  function test_scpi_instrument_trigger (line 88) | def test_scpi_instrument_trigger():
  function test_scpi_instrument_wait_to_continue (line 94) | def test_scpi_instrument_wait_to_continue():
  function test_scpi_instrument_line_frequency (line 100) | def test_scpi_instrument_line_frequency():
  function test_scpi_instrument_check_error_queue (line 121) | def test_scpi_instrument_check_error_queue():
  function test_scpi_instrument_display_brightness (line 138) | def test_scpi_instrument_display_brightness(val):
  function test_scpi_instrument_display_brightness_invalid_value (line 156) | def test_scpi_instrument_display_brightness_invalid_value(val):
  function test_scpi_instrument_display_contrast (line 166) | def test_scpi_instrument_display_contrast(val):
  function test_scpi_instrument_display_contrast_invalid_value (line 184) | def test_scpi_instrument_display_contrast_invalid_value(val):

FILE: tests/test_generic_scpi/test_scpi_multimeter.py
  function test_scpi_multimeter_mode (line 20) | def test_scpi_multimeter_mode():
  function test_scpi_multimeter_trigger_mode (line 30) | def test_scpi_multimeter_trigger_mode():
  function test_scpi_multimeter_input_range (line 38) | def test_scpi_multimeter_input_range():
  function test_scpi_multimeter_resolution (line 62) | def test_scpi_multimeter_resolution():
  function test_scpi_multimeter_resolution_type_error (line 86) | def test_scpi_multimeter_resolution_type_error():
  function test_scpi_multimeter_trigger_count (line 101) | def test_scpi_multimeter_trigger_count():
  function test_scpi_multimeter_trigger_count_type_error (line 116) | def test_scpi_multimeter_trigger_count_type_error():
  function test_scpi_multimeter_sample_count (line 129) | def test_scpi_multimeter_sample_count():
  function test_scpi_multimeter_sample_count_type_error (line 144) | def test_scpi_multimeter_sample_count_type_error():
  function test_scpi_multimeter_trigger_delay (line 157) | def test_scpi_multimeter_trigger_delay():
  function test_scpi_multimeter_sample_source (line 172) | def test_scpi_multimeter_sample_source():
  function test_scpi_multimeter_sample_timer (line 187) | def test_scpi_multimeter_sample_timer():
  function test_scpi_multimeter_relative_not_implemented (line 202) | def test_scpi_multimeter_relative_not_implemented():
  function test_scpi_multimeter_measure (line 211) | def test_scpi_multimeter_measure():
  function test_scpi_multimeter_measure_mode_none (line 224) | def test_scpi_multimeter_measure_mode_none():
  function test_scpi_multimeter_measure_invalid_mode (line 240) | def test_scpi_multimeter_measure_invalid_mode():

FILE: tests/test_gentec_eo/test_blu.py
  function test_blu_initialization (line 24) | def test_blu_initialization():
  function test_blu_anticipation (line 39) | def test_blu_anticipation():
  function test_blu_auto_scale (line 51) | def test_blu_auto_scale():
  function test_blu_available_scales (line 63) | def test_blu_available_scales():
  function test_blu_available_scales_error (line 99) | def test_blu_available_scales_error():
  function test_blu_battery_state (line 120) | def test_blu_battery_state():
  function test_blu_current_value_watts (line 131) | def test_blu_current_value_watts():
  function test_blu_current_value_joules (line 142) | def test_blu_current_value_joules():
  function test_blu_head_type (line 153) | def test_blu_head_type():
  function test_blu_measure_mode (line 168) | def test_blu_measure_mode():
  function test_blu_new_value_ready (line 190) | def test_blu_new_value_ready():
  function test_blu_scale (line 203) | def test_blu_scale(scale):
  function test_blu_single_shot_energy_mode (line 215) | def test_blu_single_shot_energy_mode():
  function test_blu_trigger_level (line 229) | def test_blu_trigger_level():
  function test_blu_trigger_level_invalid_value (line 248) | def test_blu_trigger_level_invalid_value():
  function test_blu_usb_state (line 262) | def test_blu_usb_state():
  function test_blu_user_multiplier (line 273) | def test_blu_user_multiplier():
  function test_blu_user_offset_watts (line 285) | def test_blu_user_offset_watts():
  function test_blu_user_offset_joules (line 297) | def test_blu_user_offset_joules():
  function test_blu_user_offset_unitless (line 309) | def test_blu_user_offset_unitless():
  function test_blu_user_offset_unit_error (line 320) | def test_blu_user_offset_unit_error():
  function test_blu_version (line 332) | def test_blu_version():
  function test_blu_wavelength (line 344) | def test_blu_wavelength():
  function test_blu_wavelength_out_of_bound (line 357) | def test_blu_wavelength_out_of_bound():
  function test_blu_zero_offset (line 369) | def test_blu_zero_offset():
  function test_blu_confirm_connection (line 385) | def test_blu_confirm_connection():
  function test_blu_disconnect (line 396) | def test_blu_disconnect():
  function test_blu_scale_down (line 407) | def test_blu_scale_down():
  function test_blu_scale_up (line 418) | def test_blu_scale_up():
  function test_no_ack_query_error (line 429) | def test_no_ack_query_error(mocker):
  function test_format_eight_type (line 453) | def test_format_eight_type():
  function test_format_eight_length_values (line 463) | def test_format_eight_length_values(value):

FILE: tests/test_glassman/test_glassmanfr.py
  function set_defaults (line 19) | def set_defaults(inst):
  function test_channel (line 29) | def test_channel():
  function test_voltage (line 35) | def test_voltage():
  function test_current (line 47) | def test_current():
  function test_voltage_sense (line 59) | def test_voltage_sense():
  function test_current_sense (line 67) | def test_current_sense():
  function test_mode (line 75) | def test_mode():
  function test_output (line 86) | def test_output():
  function test_output_type_error (line 99) | def test_output_type_error():
  function test_fault (line 109) | def test_fault(value):
  function test_version (line 122) | def test_version():
  function test_device_timeout (line 129) | def test_device_timeout():
  function test_device_timeout_type_error (line 139) | def test_device_timeout_type_error():
  function test_sendcmd (line 148) | def test_sendcmd():
  function test_query (line 153) | def test_query():
  function test_query_invalid_response_code (line 162) | def test_query_invalid_response_code():
  function test_query_invalid_checksum (line 174) | def test_query_invalid_checksum():
  function test_query_error (line 187) | def test_query_error(err):
  function test_reset (line 201) | def test_reset():
  function test_set_status (line 208) | def test_set_status():
  function test_parse_invalid_response (line 222) | def test_parse_invalid_response():

FILE: tests/test_hcp/test_tc038.py
  function test_sendcmd (line 16) | def test_sendcmd():
  function test_query (line 21) | def test_query():
  function test_setpoint (line 26) | def test_setpoint():
  function test_setpoint_setter (line 34) | def test_setpoint_setter():
  function test_temperature (line 42) | def test_temperature():
  function test_monitored (line 51) | def test_monitored():
  function test_set_monitored (line 60) | def test_set_monitored():
  function test_set_monitored_wrong_input (line 69) | def test_set_monitored_wrong_input():
  function test_information (line 75) | def test_information():

FILE: tests/test_hcp/test_tc038d.py
  function test_write_multiple (line 17) | def test_write_multiple():
  function test_write_multiple_CRC_error (line 28) | def test_write_multiple_CRC_error():
  function test_write_multiple_wrong_values (line 39) | def test_write_multiple_wrong_values():
  function test_write_multiple_Value_error (line 50) | def test_write_multiple_Value_error():
  function test_read_CRC_error (line 62) | def test_read_CRC_error():
  function test_read_address_error (line 73) | def test_read_address_error():
  function test_read_elements_error (line 84) | def test_read_elements_error():
  function test_read_any_error (line 95) | def test_read_any_error():
  function test_setpoint (line 106) | def test_setpoint():
  function test_setpoint_setter (line 117) | def test_setpoint_setter():
  function test_temperature (line 127) | def test_temperature():

FILE: tests/test_holzworth/test_holzworth_hs9000.py
  function test_hs9000_name (line 20) | def test_hs9000_name():
  function test_channel_idx_list (line 30) | def test_channel_idx_list():
  function test_channel_returns_inner_class (line 42) | def test_channel_returns_inner_class():
  function test_channel_sendcmd (line 56) | def test_channel_sendcmd():
  function test_channel_query (line 64) | def test_channel_query():
  function test_channel_reset (line 74) | def test_channel_reset():
  function test_channel_recall_state (line 81) | def test_channel_recall_state():
  function test_channel_save_state (line 88) | def test_channel_save_state():
  function test_channel_temperature (line 95) | def test_channel_temperature():
  function test_channel_frequency_getter (line 106) | def test_channel_frequency_getter():
  function test_channel_frequency_setter (line 119) | def test_channel_frequency_setter():
  function test_channel_power_getter (line 130) | def test_channel_power_getter():
  function test_channel_power_setter (line 143) | def test_channel_power_setter():
  function test_channel_phase_getter (line 154) | def test_channel_phase_getter():
  function test_channel_phase_setter (line 167) | def test_channel_phase_setter():
  function test_channel_output (line 178) | def test_channel_output():
  function test_hs9000_is_ready (line 191) | def test_hs9000_is_ready():

FILE: tests/test_hp/test_hp3325a.py
  function time_mock (line 21) | def time_mock(mocker):
  function test_hp3325a_high_voltage (line 26) | def test_hp3325a_high_voltage():
  function test_hp3325a_phase (line 48) | def test_hp3325a_phase():
  function test_hp3325a_amplitude (line 60) | def test_hp3325a_amplitude():
  function test_hp3325a_frequency (line 72) | def test_hp3325a_frequency():
  function test_hp3325a_offset (line 84) | def test_hp3325a_offset():
  function test_hp3325a_commands (line 96) | def test_hp3325a_commands():

FILE: tests/test_hp/test_hp3456a.py
  function time_mock (line 22) | def time_mock(mocker):
  function test_hp3456a_trigger_mode (line 27) | def test_hp3456a_trigger_mode():
  function test_hp3456a_number_of_digits (line 40) | def test_hp3456a_number_of_digits():
  function test_hp3456a_number_of_digits_invalid (line 47) | def test_hp3456a_number_of_digits_invalid():
  function test_hp3456a_auto_range (line 55) | def test_hp3456a_auto_range():
  function test_hp3456a_number_of_readings (line 68) | def test_hp3456a_number_of_readings():
  function test_hp3456a_nplc (line 76) | def test_hp3456a_nplc():
  function test_hp3456a_nplc_invalid (line 84) | def test_hp3456a_nplc_invalid():
  function test_hp3456a_mode (line 91) | def test_hp3456a_mode():
  function test_hp3456a_math_mode (line 104) | def test_hp3456a_math_mode():
  function test_hp3456a_trigger (line 117) | def test_hp3456a_trigger():
  function test_hp3456a_fetch (line 130) | def test_hp3456a_fetch():
  function test_hp3456a_variance (line 146) | def test_hp3456a_variance():
  function test_hp3456a_count (line 159) | def test_hp3456a_count():
  function test_hp3456a_mean (line 172) | def test_hp3456a_mean():
  function test_hp3456a_delay (line 185) | def test_hp3456a_delay():
  function test_hp3456a_lower (line 193) | def test_hp3456a_lower():
  function test_hp3456a_upper (line 201) | def test_hp3456a_upper():
  function test_hp3456a_ryz (line 209) | def test_hp3456a_ryz():
  function test_hp3456a_measure (line 224) | def test_hp3456a_measure():
  function test_hp3456a_input_range (line 237) | def test_hp3456a_input_range():
  function test_hp3456a_input_range_invalid_str (line 247) | def test_hp3456a_input_range_invalid_str():
  function test_hp3456a_input_range_invalid_range (line 254) | def test_hp3456a_input_range_invalid_range():
  function test_hp3456a_input_range_bad_type (line 261) | def test_hp3456a_input_range_bad_type():
  function test_hp3456a_input_range_bad_units (line 268) | def test_hp3456a_input_range_bad_units():
  function test_hp3456a_relative (line 275) | def test_hp3456a_relative():
  function test_hp3456a_relative_bad_type (line 293) | def test_hp3456a_relative_bad_type():
  function test_hp3456a_auto_zero (line 300) | def test_hp3456a_auto_zero():
  function test_hp3456a_filter (line 317) | def test_hp3456a_filter():
  function test_hp3456a_register_read_bad_name (line 334) | def test_hp3456a_register_read_bad_name():
  function test_hp3456a_register_write_bad_name (line 341) | def test_hp3456a_register_write_bad_name():
  function test_hp3456a_register_write_bad_register (line 348) | def test_hp3456a_register_write_bad_register():

FILE: tests/test_hp/test_hp6624a.py
  function test_channel_returns_inner_class (line 23) | def test_channel_returns_inner_class():
  function test_channel_sendcmd (line 30) | def test_channel_sendcmd():
  function test_channel_sendcmd_2 (line 38) | def test_channel_sendcmd_2():
  function test_channel_query (line 46) | def test_channel_query():
  function test_mode (line 56) | def test_mode():
  function test_channel_voltage (line 66) | def test_channel_voltage():
  function test_channel_current (line 74) | def test_channel_current():
  function test_channel_voltage_sense (line 82) | def test_channel_voltage_sense():
  function test_channel_current_sense (line 87) | def test_channel_current_sense():
  function test_channel_overvoltage (line 99) | def test_channel_overvoltage():
  function test_channel_overcurrent (line 107) | def test_channel_overcurrent():
  function test_channel_output (line 113) | def test_channel_output():
  function test_channel_reset (line 119) | def test_channel_reset():
  function test_all_voltage (line 127) | def test_all_voltage():
  function test_all_voltage_wrong_length (line 153) | def test_all_voltage_wrong_length():
  function test_all_current (line 160) | def test_all_current():
  function test_all_current_wrong_length (line 186) | def test_all_current_wrong_length():
  function test_all_voltage_sense (line 193) | def test_all_voltage_sense():
  function test_all_current_sense (line 204) | def test_all_current_sense():
  function test_clear (line 215) | def test_clear():
  function test_channel_count (line 220) | def test_channel_count():
  function test_channel_count_wrong_type (line 226) | def test_channel_count_wrong_type():
  function test_channel_count_too_small (line 233) | def test_channel_count_too_small():

FILE: tests/test_hp/test_hp6632b.py
  function test_hp6632b_display_textmode (line 20) | def test_hp6632b_display_textmode():
  function test_hp6632b_display_text (line 28) | def test_hp6632b_display_text():
  function test_hp6632b_output (line 36) | def test_hp6632b_output():
  function test_hp6632b_voltage (line 42) | def test_hp6632b_voltage():
  function test_hp6632b_voltage_sense (line 48) | def test_hp6632b_voltage_sense():
  function test_hp6632b_overvoltage (line 59) | def test_hp6632b_overvoltage():
  function test_hp6632b_current (line 67) | def test_hp6632b_current():
  function test_hp6632b_current_sense (line 73) | def test_hp6632b_current_sense():
  function test_hp6632b_overcurrent (line 84) | def test_hp6632b_overcurrent():
  function test_hp6632b_current_sense_range (line 92) | def test_hp6632b_current_sense_range():
  function test_hp6632b_output_dfi_source (line 100) | def test_hp6632b_output_dfi_source():
  function test_hp6632b_output_remote_inhibit (line 108) | def test_hp6632b_output_remote_inhibit():
  function test_hp6632b_digital_function (line 116) | def test_hp6632b_digital_function():
  function test_hp6632b_digital_data (line 124) | def test_hp6632b_digital_data():
  function test_hp6632b_sense_sweep_points (line 130) | def test_hp6632b_sense_sweep_points():
  function test_hp6632b_sense_sweep_interval (line 138) | def test_hp6632b_sense_sweep_interval():
  function test_hp6632b_sense_window (line 148) | def test_hp6632b_sense_window():
  function test_hp6632b_output_protection_delay (line 156) | def test_hp6632b_output_protection_delay():
  function test_hp6632b_voltage_alc_bandwidth (line 164) | def test_hp6632b_voltage_alc_bandwidth():
  function test_hp6632b_voltage_trigger (line 175) | def test_hp6632b_voltage_trigger():
  function test_hp6632b_current_trigger (line 183) | def test_hp6632b_current_trigger():
  function test_hp6632b_init_output_trigger (line 191) | def test_hp6632b_init_output_trigger():
  function test_hp6632b_abort_output_trigger (line 202) | def test_hp6632b_abort_output_trigger():
  function test_line_frequency (line 213) | def test_line_frequency():
  function test_display_brightness (line 222) | def test_display_brightness():
  function test_display_contrast (line 231) | def test_display_contrast():
  function test_hp6632b_check_error_queue (line 240) | def test_hp6632b_check_error_queue():

FILE: tests/test_hp/test_hp6652a.py
  function test_name (line 16) | def test_name():
  function test_mode (line 23) | def test_mode():
  function test_reset (line 32) | def test_reset():
  function test_display_text (line 37) | def test_display_text():
  function test_channel (line 45) | def test_channel():

FILE: tests/test_hp/test_hpe3631a.py
  function time_mock (line 21) | def time_mock(mocker):
  function test_channel (line 26) | def test_channel():
  function test_channelid (line 38) | def test_channelid():
  function test_mode (line 49) | def test_mode():
  function test_voltage (line 58) | def test_voltage():
  function test_voltage_range_negative (line 95) | def test_voltage_range_negative():
  function test_current (line 110) | def test_current():
  function test_voltage_sense (line 150) | def test_voltage_sense():
  function test_current_sense (line 157) | def test_current_sense():

FILE: tests/test_keithley/test_keithley195.py
  function init (line 31) | def init():
  function statusword (line 37) | def statusword():
  function test_keithley195_mode (line 80) | def test_keithley195_mode(init, statusword):
  function test_keithley195_mode_string (line 89) | def test_keithley195_mode_string(init, statusword):
  function test_keithley195_mode_type_error (line 98) | def test_keithley195_mode_type_error(init):
  function test_keithley195_trigger_mode (line 111) | def test_keithley195_trigger_mode(init, statusword):
  function test_keithley195_trigger_mode_string (line 120) | def test_keithley195_trigger_mode_string(init, statusword):
  function test_keithley195_trigger_mode_type_error (line 129) | def test_keithley195_trigger_mode_type_error(init):
  function test_keithley195_relative (line 142) | def test_keithley195_relative(init, statusword):
  function test_keithley195_relative_type_error (line 152) | def test_keithley195_relative_type_error(init):
  function test_keithley195_input_range (line 170) | def test_keithley195_input_range(init, statusword, range):
  function test_keithley195_input_range_auto (line 202) | def test_keithley195_input_range_auto(init, statusword):
  function test_keithley195_input_range_set_wrong_string (line 215) | def test_keithley195_input_range_set_wrong_string(init):
  function test_keithley195_input_range_set_wrong_range (line 228) | def test_keithley195_input_range_set_wrong_range(init, statusword):
  function test_keithley195_input_range_set_wrong_type (line 242) | def test_keithley195_input_range_set_wrong_type(init, statusword):
  function test_measure_mode_is_none (line 259) | def test_measure_mode_is_none(init, statusword, value):
  function test_measure_mode_is_current (line 269) | def test_measure_mode_is_current(init, statusword):
  function test_measure_new_mode (line 280) | def test_measure_new_mode(init, statusword, mocker):
  function test_parse_status_word_value_error (line 304) | def test_parse_status_word_value_error(init):
  function test_trigger (line 324) | def test_trigger(init):
  function test_auto_range (line 330) | def test_auto_range(init):

FILE: tests/test_keithley/test_keithley2182.py
  function test_channel (line 22) | def test_channel():
  function test_channel_mode (line 27) | def test_channel_mode():
  function test_channel_trigger_mode (line 43) | def test_channel_trigger_mode():
  function test_channel_relative (line 53) | def test_channel_relative():
  function test_channel_input_range (line 63) | def test_channel_input_range():
  function test_channel_measure_mode_not_none (line 73) | def test_channel_measure_mode_not_none():
  function test_channel_measure_voltage (line 81) | def test_channel_measure_voltage():
  function test_channel_measure_temperature (line 94) | def test_channel_measure_temperature():
  function test_channel_measure_unknown_temperature_units (line 104) | def test_channel_measure_unknown_temperature_units():
  function test_units (line 113) | def test_units():
  function test_fetch (line 133) | def test_fetch():
  function test_measure (line 150) | def test_measure():
  function test_measure_invalid_mode (line 163) | def test_measure_invalid_mode():
  function test_relative_get (line 170) | def test_relative_get():
  function test_relative_set_already_enabled (line 179) | def test_relative_set_already_enabled():
  function test_relative_set_start_disabled (line 197) | def test_relative_set_start_disabled():
  function test_relative_set_wrong_type (line 215) | def test_relative_set_wrong_type():
  function test_input_range (line 222) | def test_input_range():

FILE: tests/test_keithley/test_keithley485.py
  function test_zero_check (line 20) | def test_zero_check():
  function test_log (line 33) | def test_log():
  function test_input_range (line 46) | def test_input_range():
  function test_relative (line 55) | def test_relative():
  function test_eoi_mode (line 68) | def test_eoi_mode():
  function test_trigger_mode (line 81) | def test_trigger_mode():
  function test_auto_range (line 98) | def test_auto_range():
  function test_input_range_value (line 107) | def test_input_range_value(newval):
  function test_input_range_quantity (line 116) | def test_input_range_quantity():
  function test_input_range_invalid_value (line 127) | def test_input_range_invalid_value():
  function test_input_range_invalid_type (line 137) | def test_input_range_invalid_type():
  function test_input_range_invalid_string (line 151) | def test_input_range_invalid_string():
  function test_get_status (line 163) | def test_get_status():
  function test_measure (line 170) | def test_measure():
  function test_get_status_word_fails (line 178) | def test_get_status_word_fails():
  function test_parse_status_word_wrong_prefix (line 191) | def test_parse_status_word_wrong_prefix():
  function test_parse_status_word_cannot_parse (line 203) | def test_parse_status_word_cannot_parse():
  function test_parse_measurement_invalid_status (line 213) | def test_parse_measurement_invalid_status():
  function test_parse_measurement_bad_status (line 227) | def test_parse_measurement_bad_status():
  function test_parse_measurement_bad_function (line 238) | def test_parse_measurement_bad_function():
  function test_parse_measurement_bad_measurement (line 252) | def test_parse_measurement_bad_measurement():

FILE: tests/test_keithley/test_keithley580.py
  function init (line 32) | def init():
  function create_statusword (line 38) | def create_statusword():
  function create_measurement (line 86) | def create_measurement():
  function mock_time (line 111) | def mock_time(mocker):
  function test_polarity (line 123) | def test_polarity(init, create_statusword, newval):
  function test_polarity_string (line 139) | def test_polarity_string(init, newval_str):
  function test_polarity_wrong_type (line 154) | def test_polarity_wrong_type(init):
  function test_drive (line 176) | def test_drive(init, create_statusword, newval):
  function test_drive_string (line 192) | def test_drive_string(init, newval_str):
  function test_drive_wrong_type (line 207) | def test_drive_wrong_type(init):
  function test_dry_circuit_test (line 229) | def test_dry_circuit_test(init, create_statusword, newval):
  function test_dry_circuit_test_wrong_type (line 242) | def test_dry_circuit_test_wrong_type(init):
  function test_operate (line 260) | def test_operate(init, create_statusword, newval):
  function test_operate_wrong_type (line 273) | def test_operate_wrong_type(init):
  function test_relative (line 291) | def test_relative(init, create_statusword, newval):
  function test_relative_wrong_type (line 304) | def test_relative_wrong_type(init):
  function test_trigger_mode_get (line 321) | def test_trigger_mode_get(init):
  function test_trigger_mode_set (line 339) | def test_trigger_mode_set(init, newval):
  function test_trigger_mode_set_string (line 348) | def test_trigger_mode_set_string(init, newval):
  function test_trigger_mode_set_type_error (line 357) | def test_trigger_mode_set_type_error(init):
  function test_input_range_float (line 372) | def test_input_range_float(init, create_statusword, newval):
  function test_input_range_auto (line 391) | def test_input_range_auto(init, create_statusword):
  function test_input_range_float_value_error (line 411) | def test_input_range_float_value_error(init, newval):
  function test_input_range_auto_value_error (line 421) | def test_input_range_auto_value_error(init):
  function test_input_range_type_error (line 435) | def test_input_range_type_error(init):
  function test_trigger (line 453) | def test_trigger(init):
  function test_auto_range (line 459) | def test_auto_range(init):
  function test_set_calibration_value (line 467) | def test_set_calibration_value(init):
  function test_store_calibration_constants (line 477) | def test_store_calibration_constants(init):
  function test_get_status_word (line 489) | def test_get_status_word(init, create_statusword, mock_time):
  function test_get_status_word_fails (line 500) | def test_get_status_word_fails(init, mock_time):
  function test_parse_status_word (line 525) | def test_parse_status_word(init, create_statusword, line_frequency):
  function test_parse_status_word_invalid_values (line 559) | def test_parse_status_word_invalid_values(
  function test_parse_status_word_invalid_prefix (line 576) | def test_parse_status_word_invalid_prefix(init):
  function test_measure (line 593) | def test_measure(init, create_measurement, resistance):
  function test_parse_measurement (line 613) | def test_parse_measurement(
  function test_parse_measurement_invalid (line 654) | def test_parse_measurement_invalid(init, create_measurement):
  function test_sendcmd (line 675) | def test_sendcmd(init):
  function test_query (line 684) | def test_query(init):

FILE: tests/test_keithley/test_keithley6220.py
  function test_channel (line 19) | def test_channel():
  function test_voltage (line 24) | def test_voltage():
  function test_current (line 37) | def test_current():
  function test_disable (line 51) | def test_disable():

FILE: tests/test_keithley/test_keithley6514.py
  function test_valid_range (line 20) | def test_valid_range():
  function test_valid_range_invalid (line 28) | def test_valid_range_invalid():
  function test_parse_measurement (line 34) | def test_parse_measurement():
  function test_mode (line 48) | def test_mode():
  function test_trigger_source (line 56) | def test_trigger_source():
  function test_arm_source (line 64) | def test_arm_source():
  function test_zero_check (line 72) | def test_zero_check():
  function test_zero_correct (line 80) | def test_zero_correct():
  function test_unit (line 88) | def test_unit():
  function test_auto_range (line 99) | def test_auto_range():
  function test_input_range (line 109) | def test_input_range():
  function test_input_range_invalid (line 124) | def test_input_range_invalid():
  function test_auto_config (line 131) | def test_auto_config():
  function test_fetch (line 142) | def test_fetch():
  function test_read (line 156) | def test_read():

FILE: tests/test_lakeshore/test_lakeshore336.py
  function test_lakeshore336_sensor_init (line 21) | def test_lakeshore336_sensor_init():
  function test_lakeshore336_sensor_temperature (line 36) | def test_lakeshore336_sensor_temperature(idx_ch):

FILE: tests/test_lakeshore/test_lakeshore340.py
  function test_lakeshore340_sensor_init (line 19) | def test_lakeshore340_sensor_init():
  function test_lakeshore340_sensor_temperature (line 33) | def test_lakeshore340_sensor_temperature():

FILE: tests/test_lakeshore/test_lakeshore370.py
  function init (line 22) | def init():
  function test_lakeshore370_channel_init (line 30) | def test_lakeshore370_channel_init(init):
  function test_lakeshore370_channel_resistance (line 44) | def test_lakeshore370_channel_resistance(init):

FILE: tests/test_lakeshore/test_lakeshore475.py
  function test_lakeshore475_field (line 20) | def test_lakeshore475_field():
  function test_lakeshore475_field_units (line 32) | def test_lakeshore475_field_units():
  function test_lakeshore475_field_units_invalid_unit (line 45) | def test_lakeshore475_field_units_invalid_unit():
  function test_lakeshore475_field_units_not_a_unit (line 60) | def test_lakeshore475_field_units_not_a_unit():
  function test_lakeshore475_temp_units (line 75) | def test_lakeshore475_temp_units():
  function test_lakeshore475_temp_units_invalid_unit (line 88) | def test_lakeshore475_temp_units_invalid_unit():
  function test_lakeshore475_temp_units_not_a_unit (line 103) | def test_lakeshore475_temp_units_not_a_unit():
  function test_lakeshore475_field_setpoint (line 118) | def test_lakeshore475_field_setpoint():
  function test_lakeshore475_field_setpoint_wrong_units (line 140) | def test_lakeshore475_field_setpoint_wrong_units():
  function test_lakeshore475_field_get_control_params (line 157) | def test_lakeshore475_field_get_control_params():
  function test_lakeshore475_field_set_control_params (line 175) | def test_lakeshore475_field_set_control_params():
  function test_lakeshore475_field_set_control_params_not_a_tuple (line 195) | def test_lakeshore475_field_set_control_params_not_a_tuple():
  function test_lakeshore475_field_set_control_params_wrong_units (line 210) | def test_lakeshore475_field_set_control_params_wrong_units():
  function test_lakeshore475_p_value (line 237) | def test_lakeshore475_p_value():
  function test_lakeshore475_i_value (line 263) | def test_lakeshore475_i_value():
  function test_lakeshore475_ramp_rate (line 289) | def test_lakeshore475_ramp_rate():
  function test_lakeshore475_control_slope_limit (line 327) | def test_lakeshore475_control_slope_limit():
  function test_lakeshore475_control_mode (line 361) | def test_lakeshore475_control_mode():
  function test_lakeshore475_change_measurement_mode (line 377) | def test_lakeshore475_change_measurement_mode():
  function test_lakeshore475_change_measurement_mode_mismatched_type (line 397) | def test_lakeshore475_change_measurement_mode_mismatched_type():
  function test_lakeshore475_change_measurement_mode_invalid_resolution (line 456) | def test_lakeshore475_change_measurement_mode_invalid_resolution():

FILE: tests/test_mettler_toledo/test_mt_sics.py
  function test_clear_tare (line 17) | def test_clear_tare():
  function test_reset (line 25) | def test_reset():
  function test_tare (line 34) | def test_tare(mode):
  function test_zero (line 50) | def test_zero(mode):
  function test_command_error_checking (line 66) | def test_command_error_checking(err):
  function test_general_error_checking (line 76) | def test_general_error_checking(err):
  function test_mt_sics (line 86) | def test_mt_sics():
  function test_mt_sics_commands (line 94) | def test_mt_sics_commands():
  function test_mt_sics_commands_timeout (line 102) | def test_mt_sics_commands_timeout(mocker):
  function test_name (line 116) | def test_name():
  function test_name_too_long (line 128) | def test_name_too_long():
  function test_serial_number (line 135) | def test_serial_number():
  function test_tare_value (line 143) | def test_tare_value():
  function test_weight (line 156) | def test_weight(mode):
  function test_weight_immediately_dynamic_mode (line 166) | def test_weight_immediately_dynamic_mode():
  function test_weight_mode_type_error (line 176) | def test_weight_mode_type_error():

FILE: tests/test_minghe/test_minghe_mhs5200a.py
  function test_mhs_amplitude (line 18) | def test_mhs_amplitude():
  function test_mhs_amplitude_dbm_notimplemented (line 31) | def test_mhs_amplitude_dbm_notimplemented():
  function test_mhs_duty_cycle (line 37) | def test_mhs_duty_cycle():
  function test_mhs_enable (line 50) | def test_mhs_enable():
  function test_mhs_frequency (line 63) | def test_mhs_frequency():
  function test_mhs_offset (line 76) | def test_mhs_offset():
  function test_mhs_phase (line 89) | def test_mhs_phase():
  function test_mhs_wave_type (line 102) | def test_mhs_wave_type():
  function test_mhs_serial_number (line 115) | def test_mhs_serial_number():
  function test_mhs_get_amplitude (line 127) | def test_mhs_get_amplitude():
  function test_mhs_set_amplitude (line 134) | def test_mhs_set_amplitude():

FILE: tests/test_named_struct.py
  class TestNamedStruct (line 22) | class TestNamedStruct(TestCase):
    method test_roundtrip (line 27) | def test_roundtrip(self, var1, var2):
    method test_str (line 36) | def test_str(self):
    method test_negative_len (line 50) | def test_negative_len(self):
    method test_equality (line 59) | def test_equality(self):

FILE: tests/test_newport/test_agilis.py
  function mock_time (line 25) | def mock_time(mocker):
  function test_aguc2_enable_remote_mode (line 33) | def test_aguc2_enable_remote_mode():
  function test_aguc2_error_previous_command_no_error (line 44) | def test_aguc2_error_previous_command_no_error():
  function test_aguc2_error_previous_command (line 50) | def test_aguc2_error_previous_command():
  function test_aguc2_firmware_version (line 60) | def test_aguc2_firmware_version():
  function test_aguc2_limit_status (line 71) | def test_aguc2_limit_status():
  function test_aguc2_sleep_time (line 81) | def test_aguc2_sleep_time():
  function test_aguc2_reset_controller (line 92) | def test_aguc2_reset_controller():
  function test_aguc2_ag_sendcmd (line 101) | def test_aguc2_ag_sendcmd():
  function test_aguc2_ag_query (line 111) | def test_aguc2_ag_query():
  function test_aguc2_ag_query_io_error (line 121) | def test_aguc2_ag_query_io_error(mocker):
  function test_aguc2_axis_init_enum (line 136) | def test_aguc2_axis_init_enum(axis):
  function test_aguc2_axis_init_wrong_type (line 143) | def test_aguc2_axis_init_wrong_type():
  function test_aguc2_axis_am_i_still (line 153) | def test_aguc2_axis_am_i_still(axis, still):
  function test_aguc2_axis_am_i_still_io_error (line 167) | def test_aguc2_axis_am_i_still_io_error():
  function test_aguc2_axis_axis_status_not_moving (line 182) | def test_aguc2_axis_axis_status_not_moving(axis):
  function test_aguc2_axis_axis_status (line 196) | def test_aguc2_axis_axis_status():
  function test_aguc2_axis_jog (line 211) | def test_aguc2_axis_jog():
  function test_aguc2_axis_number_of_steps (line 229) | def test_aguc2_axis_number_of_steps():
  function test_aguc2_axis_move_relative (line 245) | def test_aguc2_axis_move_relative():
  function test_aguc2_axis_move_to_limit (line 265) | def test_aguc2_axis_move_to_limit():
  function test_aguc2_axis_step_amplitude (line 284) | def test_aguc2_axis_step_amplitude():
  function test_aguc2_axis_step_delay (line 314) | def test_aguc2_axis_step_delay():
  function test_aguc2_axis_stop (line 333) | def test_aguc2_axis_stop():
  function test_aguc2_axis_zero_position (line 347) | def test_aguc2_axis_zero_position():
  function test_agilis_error_message (line 364) | def test_agilis_error_message():
  function test_agilis_status_message (line 384) | def test_agilis_status_message():

FILE: tests/test_newport/test_errors.py
  function test_init_none (line 19) | def test_init_none():
  function test_init_with_timestamp (line 27) | def test_init_with_timestamp():
  function test_init_with_error_code (line 34) | def test_init_with_error_code():
  function test_init_with_error_code_axis (line 42) | def test_init_with_error_code_axis():
  function test_get_message (line 50) | def test_get_message():
  function test_timestamp (line 57) | def test_timestamp():
  function test_errcode (line 63) | def test_errcode():
  function test_axis (line 69) | def test_axis():

FILE: tests/test_newport/test_newport_pmc8742.py
  function test_init (line 21) | def test_init():
  function test_controller_address (line 30) | def test_controller_address():
  function test_controller_configuration (line 39) | def test_controller_configuration():
  function test_dhcp_mode (line 53) | def test_dhcp_mode():
  function test_error_code (line 66) | def test_error_code():
  function test_error_code_and_message (line 74) | def test_error_code_and_message():
  function test_firmware_version (line 88) | def test_firmware_version():
  function test_gateway (line 96) | def test_gateway():
  function test_hostname (line 109) | def test_hostname():
  function test_ip_address (line 122) | def test_ip_address():
  function test_mac_address (line 135) | def test_mac_address():
  function test_name (line 144) | def test_name():
  function test_netmask (line 152) | def test_netmask():
  function test_scan_controller (line 165) | def test_scan_controller():
  function test_scan_done (line 173) | def test_scan_done():
  function test_abort_motion (line 182) | def test_abort_motion():
  function test_motor_check (line 190) | def test_motor_check():
  function test_scan (line 199) | def test_scan(mode):
  function test_purge (line 208) | def test_purge():
  function test_recall_parameters (line 217) | def test_recall_parameters(mode):
  function test_reset (line 226) | def test_reset():
  function test_save_settings (line 234) | def test_save_settings():
  function test_query_bad_header (line 242) | def test_query_bad_header():
  fun

[
  {
    "path": ".coveragerc",
    "chars": 347,
    "preview": "[paths]\nsource =\n    src\n    */site-packages\n\n[report]\nomit =\n    */python?.?/*\n    */site-packages/nose/*\n    *__init__"
  },
  {
    "path": ".github/workflows/deploy.yml",
    "chars": 672,
    "preview": "name: Upload Python Package\n\non:\n  release:\n    types: [published]\n\njobs:\n  deploy:\n    runs-on: ubuntu-latest\n    steps"
  },
  {
    "path": ".github/workflows/test.yml",
    "chars": 1805,
    "preview": "name: Testing\n\non:\n  push:\n    branches: [ main ]\n  pull_request:\n\njobs:\n  static-checks:\n    runs-on: ubuntu-latest\n   "
  },
  {
    "path": ".gitignore",
    "chars": 788,
    "preview": "## Temporary files ##\n*~\n*.tmp\n\n## OS generated files ##\n.DS_Store*\ndesktop.ini\nThumbs.db\n\n## Build directories ##\ndoc/_"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 498,
    "preview": "repos:\n  - repo: https://github.com/pre-commit/pre-commit-hooks\n    rev: v6.0.0\n    hooks:\n      - id: no-commit-to-bran"
  },
  {
    "path": ".readthedocs.yml",
    "chars": 244,
    "preview": "version: 2\nbuild:\n  os: ubuntu-24.04\n  tools:\n    python: \"3.13\"\n\nsphinx:\n  builder: html\n  configuration: doc/source/co"
  },
  {
    "path": "README.rst",
    "chars": 5992,
    "preview": "InstrumentKit\n=============\n\n.. image:: https://github.com/instrumentkit/InstrumentKit/workflows/Testing/badge.svg?branc"
  },
  {
    "path": "doc/Makefile",
    "chars": 5657,
    "preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS    =\nSPHINXBUILD "
  },
  {
    "path": "doc/examples/.ipynb_checkpoints/ex_keithley6514-checkpoint.ipynb",
    "chars": 3538,
    "preview": "{\n \"metadata\": {\n  \"name\": \"\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": [\n    {\n     \"c"
  },
  {
    "path": "doc/examples/ex_generic_scpi.ipynb",
    "chars": 2220,
    "preview": "{\n \"metadata\": {\n  \"name\": \"ex_generic_scpi\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": "
  },
  {
    "path": "doc/examples/ex_generic_scpi.py",
    "chars": 1062,
    "preview": "# <nbformat>3.0</nbformat>\n\n# <headingcell level=1>\n\n# InstrumentKit Library Examples\n\n# <headingcell level=2>\n\n# Generi"
  },
  {
    "path": "doc/examples/ex_hp3325.py",
    "chars": 367,
    "preview": "import logging\n\nimport instruments as ik\n\nfcngen = ik.hp.HP3325a.open_gpibusb(\"COM4\", 17, model=\"pl\")\nlogging.basicConfi"
  },
  {
    "path": "doc/examples/ex_hp3456.out",
    "chars": 9743,
    "preview": "DEBUG:instruments.abstract_instruments.comm.gi_gpib: <- 'T4'\nDEBUG:instruments.abstract_instruments.comm.gi_gpib: <- 'W6"
  },
  {
    "path": "doc/examples/ex_hp3456.py",
    "chars": 1629,
    "preview": "#!/usr/bin/python\n\nimport logging\nimport time\nimport instruments as ik\nimport instruments.units as u\n\ndmm = ik.hp.HP3456"
  },
  {
    "path": "doc/examples/ex_keithley195.ipynb",
    "chars": 1945,
    "preview": "{\n \"metadata\": {\n  \"name\": \"ex_keithley195\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": ["
  },
  {
    "path": "doc/examples/ex_keithley195.py",
    "chars": 871,
    "preview": "# <nbformat>3.0</nbformat>\n\n# <headingcell level=1>\n\n# InstrumentKit Library Examples\n\n# <headingcell level=2>\n\n# Keithl"
  },
  {
    "path": "doc/examples/ex_keithley6514.ipynb",
    "chars": 42683,
    "preview": "{\n \"metadata\": {\n  \"name\": \"\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": [\n    {\n     \"c"
  },
  {
    "path": "doc/examples/ex_maui.ipynb",
    "chars": 91010,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# MAUI Oscilloscope controller\\n\",\n"
  },
  {
    "path": "doc/examples/ex_oscilloscope_waveform.ipynb",
    "chars": 2841,
    "preview": "{\n \"metadata\": {\n  \"name\": \"ex_oscilloscope_waveform\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   "
  },
  {
    "path": "doc/examples/ex_oscilloscope_waveform.py",
    "chars": 1411,
    "preview": "# <nbformat>3.0</nbformat>\n\n# <headingcell level=1>\n\n# InstrumentKit Library Examples\n\n# <headingcell level=2>\n\n# Tektro"
  },
  {
    "path": "doc/examples/ex_qubitekk_gui.py",
    "chars": 7032,
    "preview": "#!/usr/bin/python\n# Qubitekk Coincidence Counter example\nimport matplotlib\n\nmatplotlib.use(\"TkAgg\")\n\nfrom matplotlib.fig"
  },
  {
    "path": "doc/examples/ex_qubitekkcc.py",
    "chars": 656,
    "preview": "#!/usr/bin/python\nfrom sys import platform as _platform\n\nimport instruments as ik\nimport instruments.units as u\n\n\ndef ma"
  },
  {
    "path": "doc/examples/ex_qubitekkcc_simple.py",
    "chars": 921,
    "preview": "#!/usr/bin/python\n# Qubitekk Coincidence Counter example\n\nfrom sys import platform as _platform\n\nimport instruments as i"
  },
  {
    "path": "doc/examples/ex_tekdpo70000.ipynb",
    "chars": 39146,
    "preview": "{\n \"metadata\": {\n  \"name\": \"\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": [\n    {\n     \"c"
  },
  {
    "path": "doc/examples/ex_thorlabslcc.py",
    "chars": 299,
    "preview": "# Thorlabs Liquid Crystal Controller example\n\nimport instruments as ik\n\nlcc = ik.thorlabs.LCC25.open_serial(\"COM10\", 115"
  },
  {
    "path": "doc/examples/ex_thorlabssc10.py",
    "chars": 940,
    "preview": "# Thorlabs Shutter Controller example\n\nimport instruments as ik\n\n# if the baud mode is set to 1, then the baud rate is 1"
  },
  {
    "path": "doc/examples/ex_thorlabstc200.py",
    "chars": 942,
    "preview": "# Thorlabs Temperature Controller example\n\nimport instruments as ik\nimport instruments.units as u\n\ntc = ik.thorlabs.TC20"
  },
  {
    "path": "doc/examples/ex_topticatopmode.py",
    "chars": 1896,
    "preview": "#!/usr/bin/env python\n\"\"\"\nToptica Topmode example\n\"\"\"\n\nimport instruments as ik\nimport instruments.units as u\nfrom platf"
  },
  {
    "path": "doc/examples/example2.py",
    "chars": 793,
    "preview": "#!/usr/bin/python\n# Filename: example2.py\n\n# Example 1:\n# \t- Import required packages\n# \t- Create object for our Tek TDS"
  },
  {
    "path": "doc/examples/minghe/ex_minghe_mhs5200.py",
    "chars": 851,
    "preview": "#!/usr/bin/python\nfrom instruments.minghe import MHS5200\nimport instruments.units as u\n\nmhs = MHS5200.open_serial(vid=67"
  },
  {
    "path": "doc/examples/qubitekk/ex_qubitekk_mc1.py",
    "chars": 1149,
    "preview": "#!/usr/bin/python\n# Qubitekk Motor controller example\nfrom time import sleep\n\nfrom instruments.qubitekk import MC1\nimpor"
  },
  {
    "path": "doc/examples/srs_DG645.ipynb",
    "chars": 6842,
    "preview": "{\n \"metadata\": {\n  \"name\": \"srs_DG645\"\n },\n \"nbformat\": 3,\n \"nbformat_minor\": 0,\n \"worksheets\": [\n  {\n   \"cells\": [\n    "
  },
  {
    "path": "doc/examples/srs_DG645.py",
    "chars": 1009,
    "preview": "# <nbformat>3.0</nbformat>\n\n# <headingcell level=1>\n\n# InstrumentKit Library Examples\n\n# <headingcell level=2>\n\n# Stanfo"
  },
  {
    "path": "doc/make.bat",
    "chars": 5147,
    "preview": "@ECHO OFF\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-build\n)\nset BUI"
  },
  {
    "path": "doc/source/acknowledgements.rst",
    "chars": 849,
    "preview": "================\nAcknowledgements\n================\n\nHere I've done my best to keep a list of all those who have made a c"
  },
  {
    "path": "doc/source/apiref/agilent.rst",
    "chars": 415,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.agilent\n\n=======\nAgilent\n=======\n\n:c"
  },
  {
    "path": "doc/source/apiref/aimtti.rst",
    "chars": 204,
    "preview": ".. currentmodule:: instruments.aimtti\n\n=======\nAim-TTi\n=======\n\n:class:`AimTTiEL302P` Power Supply\n====================="
  },
  {
    "path": "doc/source/apiref/comet.rst",
    "chars": 197,
    "preview": ".. currentmodule:: instruments.comet\n\n=====\nComet\n=====\n\n:class:`CitoPlus1310` RF Generator\n============================"
  },
  {
    "path": "doc/source/apiref/config.rst",
    "chars": 702,
    "preview": "==========================\nConfiguration File Support\n==========================\n\n.. currentmodule:: instruments\n\nThe `i"
  },
  {
    "path": "doc/source/apiref/delta_elektronika.rst",
    "chars": 270,
    "preview": ".. currentmodule:: instruments.delta_elektronika\n\n=================\nDelta Elektronika\n=================\n\n:class:`PscEth`"
  },
  {
    "path": "doc/source/apiref/dressler.rst",
    "chars": 193,
    "preview": ".. currentmodule:: instruments.dressler\n\n========\nDressler\n========\n\n:class:`Cesar1312` RF Generator\n==================="
  },
  {
    "path": "doc/source/apiref/fluke.rst",
    "chars": 244,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.fluke\n\n=====\nFluke\n=====\n\n:class:`Fl"
  },
  {
    "path": "doc/source/apiref/generic_scpi.rst",
    "chars": 831,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. _apiref-generic_scpi:\n.. currentmodule:: instruments.generic_scp"
  },
  {
    "path": "doc/source/apiref/gentec-eo.rst",
    "chars": 192,
    "preview": ".. currentmodule:: instruments.gentec_eo\n\n=========\nGentec-EO\n=========\n\n:class:`Blu` Power Meter\n======================"
  },
  {
    "path": "doc/source/apiref/glassman.rst",
    "chars": 277,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.glassman\n\n========\nGlassman\n========"
  },
  {
    "path": "doc/source/apiref/hcp.rst",
    "chars": 369,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.hcp\n\n============\nHC Photonics\n====="
  },
  {
    "path": "doc/source/apiref/holzworth.rst",
    "chars": 285,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.holzworth\n\n=========\nHolzworth\n====="
  },
  {
    "path": "doc/source/apiref/hp.rst",
    "chars": 772,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.hp\n\n===============\nHewlett-Packard\n"
  },
  {
    "path": "doc/source/apiref/index.rst",
    "chars": 561,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. _apiref:\n\nInstrumentKit API Reference\n=========================="
  },
  {
    "path": "doc/source/apiref/instrument.rst",
    "chars": 2582,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments\n\n=======================\nInstrument "
  },
  {
    "path": "doc/source/apiref/keithley.rst",
    "chars": 1163,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.keithley\n\n========\nKeithley\n========"
  },
  {
    "path": "doc/source/apiref/lakeshore.rst",
    "chars": 753,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.lakeshore\n\n=========\nLakeshore\n====="
  },
  {
    "path": "doc/source/apiref/mettler_toledo.rst",
    "chars": 325,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.mettler_toledo\n\n==============\nMettl"
  },
  {
    "path": "doc/source/apiref/minghe.rst",
    "chars": 244,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.minghe\n\n======\nMinghe\n======\n\n:class"
  },
  {
    "path": "doc/source/apiref/newport.rst",
    "chars": 646,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.newport\n\n=======\nNewport\n=======\n\n:c"
  },
  {
    "path": "doc/source/apiref/ondax.rst",
    "chars": 243,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.ondax\n\n=====\nOndax\n=====\n\n:class:`LM"
  },
  {
    "path": "doc/source/apiref/oxford.rst",
    "chars": 267,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.oxford\n\n======\nOxford\n======\n\n:class"
  },
  {
    "path": "doc/source/apiref/pfeiffer.rst",
    "chars": 263,
    "preview": ".. currentmodule:: instruments.pfeiffer\n\n===========================\nPfeiffer Vacuum Instruments\n======================="
  },
  {
    "path": "doc/source/apiref/phasematrix.rst",
    "chars": 293,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.phasematrix\n\n===========\nPhaseMatrix"
  },
  {
    "path": "doc/source/apiref/picowatt.rst",
    "chars": 268,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.picowatt\n\n========\nPicowatt\n========"
  },
  {
    "path": "doc/source/apiref/qubitekk.rst",
    "chars": 357,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.qubitekk\n\n========\nQubitekk\n========"
  },
  {
    "path": "doc/source/apiref/rigol.rst",
    "chars": 258,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.rigol\n\n=====\nRigol\n=====\n\n:class:`Ri"
  },
  {
    "path": "doc/source/apiref/srs.rst",
    "chars": 730,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.srs\n\n=========================\nStanf"
  },
  {
    "path": "doc/source/apiref/sunpower.rst",
    "chars": 225,
    "preview": ".. currentmodule:: instruments.sunpower\n\n====================\nSunpower Instruments\n====================\n\n:class:`CryoTel"
  },
  {
    "path": "doc/source/apiref/tektronix.rst",
    "chars": 786,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.tektronix\n\n=========\nTektronix\n====="
  },
  {
    "path": "doc/source/apiref/teledyne.rst",
    "chars": 276,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.teledyne\n\n===============\nTeledyne-L"
  },
  {
    "path": "doc/source/apiref/thorlabs.rst",
    "chars": 1100,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.thorlabs\n\n========\nThorLabs\n========"
  },
  {
    "path": "doc/source/apiref/toptica.rst",
    "chars": 385,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.toptica\n\n=======\nToptica\n=======\n\n:c"
  },
  {
    "path": "doc/source/apiref/yokogawa.rst",
    "chars": 415,
    "preview": "..\n    TODO: put documentation license header here.\n\n.. currentmodule:: instruments.yokogawa\n\n========\nYokogawa\n========"
  },
  {
    "path": "doc/source/conf.py",
    "chars": 8634,
    "preview": "#\n# InstrumentKit Library documentation build configuration file, created by\n# sphinx-quickstart on Fri Apr  5 10:37:03 "
  },
  {
    "path": "doc/source/devguide/code_style.rst",
    "chars": 4183,
    "preview": ".. _code_style:\n\n============\nCoding Style\n============\n\nData Types\n==========\n\nNumeric Data\n------------\n\nWhen appropri"
  },
  {
    "path": "doc/source/devguide/design_philosophy.rst",
    "chars": 2536,
    "preview": "=================\nDesign Philosophy\n=================\n\nHere, we describe the design philosophy behind InstrumentKit at a"
  },
  {
    "path": "doc/source/devguide/index.rst",
    "chars": 2846,
    "preview": "===============================\nInstrumentKit Development Guide\n===============================\n\n.. toctree::\n    :maxde"
  },
  {
    "path": "doc/source/devguide/testing.rst",
    "chars": 5154,
    "preview": "================================\nTesting Instrument Functionality\n================================\n\n.. currentmodule:: i"
  },
  {
    "path": "doc/source/devguide/util_fns.rst",
    "chars": 5865,
    "preview": "=============================\nUtility Functions and Classes\n=============================\n\n.. currentmodule:: instrument"
  },
  {
    "path": "doc/source/index.rst",
    "chars": 357,
    "preview": "..\n    TODO: put documentation license header here.\n\nWelcome to InstrumentKit Library's documentation!\n================="
  },
  {
    "path": "doc/source/intro.rst",
    "chars": 4622,
    "preview": "..\n    TODO: put documentation license header here.\n\n============\nIntroduction\n============\n\n**InstrumentKit** allows fo"
  },
  {
    "path": "license/AUTHOR.TXT",
    "chars": 102,
    "preview": "Original author:\n\nSteven Casagrande\nstevencasagrande@gmail.com\ntwitter.com/stevecasagrande\n\n2012-2025\n"
  },
  {
    "path": "license/LICENSE.TXT",
    "chars": 31772,
    "preview": "GNU AFFERO GENERAL PUBLIC LICENSE\n\nVersion 3, 19 November 2007\n\nCopyright © 2007 Free Software Foundation, Inc. <http://"
  },
  {
    "path": "matlab/matlab-example.ipynb",
    "chars": 2277,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Loading Instruments from MATLAB #"
  },
  {
    "path": "matlab/open_instrument.m",
    "chars": 1549,
    "preview": "function instrument = open_instrument(name, uri)\n% open_instrument Opens an instrument given its InstrumentKit URI.\n%\n% "
  },
  {
    "path": "pyproject.toml",
    "chars": 1915,
    "preview": "[build-system]\nrequires = [\"setuptools>=61.2\", \"setuptools_scm>=9.2\"]\nbuild-backend = \"setuptools.build_meta\"\n\n[project]"
  },
  {
    "path": "src/instruments/__init__.py",
    "chars": 1047,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDefines globally-available subpackages and symbols for the instruments package.\n\"\"\"\n\n# IMPORTS"
  },
  {
    "path": "src/instruments/abstract_instruments/__init__.py",
    "chars": 406,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing instrument abstract base classes and communication layers\n\"\"\"\n\nfrom .instrum"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/__init__.py",
    "chars": 571,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing communication layers\n\"\"\"\n\nfrom .abstract_comm import AbstractCommunicator\n\nf"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/abstract_comm.py",
    "chars": 7342,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for file-like communication layer classes\n\"\"\"\n\n# IMPORTS #####"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/file_communicator.py",
    "chars": 7175,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a communication layer for an instrument with a file on the filesystem\n\"\"\"\n\n# IMPORTS "
  },
  {
    "path": "src/instruments/abstract_instruments/comm/gpib_communicator.py",
    "chars": 12343,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a communication layer for an instrument connected via a Galvant\nIndustries or Prologi"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/loopback_communicator.py",
    "chars": 5862,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a loopback communicator, used for creating unit tests or for opening\ntest connections"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/serial_communicator.py",
    "chars": 6287,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a serial communicator for connecting with instruments over serial\nconnections.\n\"\"\"\n\n#"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/serial_manager.py",
    "chars": 2807,
    "preview": "#!/usr/bin/env python\n\"\"\"\nThis module handles creating the serial objects for the instrument classes.\n\nThis is needed fo"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/socket_communicator.py",
    "chars": 5629,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a tcpip socket communicator for connecting with instruments over\nraw ethernet connect"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/usb_communicator.py",
    "chars": 6145,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a USB communicator for connecting with instruments over raw usb\nconnections.\n\"\"\"\n\n# I"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/usbtmc_communicator.py",
    "chars": 5297,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a communicator that uses Python-USBTMC for connecting with TMC\ninstruments.\n\"\"\"\n\n# IM"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/visa_communicator.py",
    "chars": 6268,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a VISA communicator for connecting with instruments via the VISA\nlibrary.\n\"\"\"\n\n# IMPO"
  },
  {
    "path": "src/instruments/abstract_instruments/comm/vxi11_communicator.py",
    "chars": 5549,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides a communication layer that uses python-vxi11 to interface with\nVXI11 devices.\n\"\"\"\n\n# "
  },
  {
    "path": "src/instruments/abstract_instruments/electrometer.py",
    "chars": 2749,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for electrometer instruments\n\"\"\"\n\n# IMPORTS ##################"
  },
  {
    "path": "src/instruments/abstract_instruments/function_generator.py",
    "chars": 10068,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for function generator instruments\n\"\"\"\n\n# IMPORTS ############"
  },
  {
    "path": "src/instruments/abstract_instruments/instrument.py",
    "chars": 28926,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides the base Instrument class for all instruments.\n\"\"\"\n\n# IMPORTS #######################"
  },
  {
    "path": "src/instruments/abstract_instruments/multimeter.py",
    "chars": 1997,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for multimeter instruments\n\"\"\"\n\n# IMPORTS ####################"
  },
  {
    "path": "src/instruments/abstract_instruments/optical_spectrum_analyzer.py",
    "chars": 5382,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for optical spectrum analyzer instruments\n\"\"\"\n\n# IMPORTS #####"
  },
  {
    "path": "src/instruments/abstract_instruments/oscilloscope.py",
    "chars": 4412,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for oscilloscope instruments\n\"\"\"\n\n# IMPORTS ##################"
  },
  {
    "path": "src/instruments/abstract_instruments/power_supply.py",
    "chars": 3236,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for power supply instruments\n\"\"\"\n\n# IMPORTS ##################"
  },
  {
    "path": "src/instruments/abstract_instruments/signal_generator/__init__.py",
    "chars": 212,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing signal generator abstract base classes\n\"\"\"\n\nfrom .signal_generator import Si"
  },
  {
    "path": "src/instruments/abstract_instruments/signal_generator/channel.py",
    "chars": 1685,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for signal generator output channels\n\"\"\"\n\n# IMPORTS ##########"
  },
  {
    "path": "src/instruments/abstract_instruments/signal_generator/signal_generator.py",
    "chars": 889,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for signal generator instruments\n\"\"\"\n\n# IMPORTS ##############"
  },
  {
    "path": "src/instruments/abstract_instruments/signal_generator/single_channel_sg.py",
    "chars": 1037,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides an abstract base class for signal generators with only a single\noutput channel.\n\"\"\"\n\n"
  },
  {
    "path": "src/instruments/agilent/__init__.py",
    "chars": 189,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Agilent instruments\n\"\"\"\n\nfrom instruments.agilent.agilent33220a import Agile"
  },
  {
    "path": "src/instruments/agilent/agilent33220a.py",
    "chars": 4939,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Agilent 33220a function generator.\n\"\"\"\n\n# IMPORTS ###################"
  },
  {
    "path": "src/instruments/agilent/agilent34410a.py",
    "chars": 7369,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Agilent 34410a digital multimeter.\n\"\"\"\n\n# IMPORTS ###################"
  },
  {
    "path": "src/instruments/aimtti/__init__.py",
    "chars": 111,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Aim-TTi power supplies\n\"\"\"\n\nfrom .aimttiel302p import AimTTiEL302P\n"
  },
  {
    "path": "src/instruments/aimtti/aimttiel302p.py",
    "chars": 4620,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Aim-TTI EL302P power supply\n\"\"\"\n\n# IMPORTS ##########################"
  },
  {
    "path": "src/instruments/comet/__init__.py",
    "chars": 87,
    "preview": "\"\"\"\nModule containing Comet instruments.\n\"\"\"\n\nfrom .cito_plus_1310 import CitoPlus1310\n"
  },
  {
    "path": "src/instruments/comet/cito_plus_1310.py",
    "chars": 13244,
    "preview": "#!/usr/bin/env python\n\"\"\"Support for Comet Cito Plus RF generator.\"\"\"\n\n# IMPORTS #######################################"
  },
  {
    "path": "src/instruments/config.py",
    "chars": 5777,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing support for loading instruments from configuration files.\n\"\"\"\n\n# IMPORTS ###"
  },
  {
    "path": "src/instruments/delta_elektronika/__init__.py",
    "chars": 136,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Delta Elektronika instruments\n\"\"\"\n\nfrom instruments.delta_elektronika.psc_et"
  },
  {
    "path": "src/instruments/delta_elektronika/psc_eth.py",
    "chars": 6588,
    "preview": "\"\"\"Support for Delta Elektronika DC power supplies with PSC-ETH-2 interface.\"\"\"\n\n# IMPORTS #############################"
  },
  {
    "path": "src/instruments/dressler/__init__.py",
    "chars": 124,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Dressler instruments\n\"\"\"\n\nfrom instruments.dressler.cesar_1312 import Cesar1"
  },
  {
    "path": "src/instruments/dressler/cesar_1312.py",
    "chars": 13158,
    "preview": "\"\"\"Support for Dressler Cesar 1312 RF generator.\"\"\"\n\n# IMPORTS #########################################################"
  },
  {
    "path": "src/instruments/errors.py",
    "chars": 697,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing custom exception errors used by various instruments.\n\"\"\"\n\n# IMPORTS ########"
  },
  {
    "path": "src/instruments/fluke/__init__.py",
    "chars": 100,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Fluke instruments\n\"\"\"\n\nfrom .fluke3000 import Fluke3000\n"
  },
  {
    "path": "src/instruments/fluke/fluke3000.py",
    "chars": 16097,
    "preview": "#!/usr/bin/env python\n#\n# fluke3000.py: Driver for the Fluke 3000 FC Industrial System\n#\n# © 2019 Francois Drielsma (fra"
  },
  {
    "path": "src/instruments/generic_scpi/__init__.py",
    "chars": 221,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing generic SCPI instruments\n\"\"\"\n\nfrom .scpi_instrument import SCPIInstrument\nfr"
  },
  {
    "path": "src/instruments/generic_scpi/scpi_function_generator.py",
    "chars": 3129,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for SCPI compliant function generators\n\"\"\"\n\n# IMPORTS #######################"
  },
  {
    "path": "src/instruments/generic_scpi/scpi_instrument.py",
    "chars": 9175,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for SCPI compliant instruments\n\"\"\"\n\n# IMPORTS ###############################"
  },
  {
    "path": "src/instruments/generic_scpi/scpi_multimeter.py",
    "chars": 13812,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for SCPI compliant multimeters\n\"\"\"\n\n# IMPORTS ###############################"
  },
  {
    "path": "src/instruments/gentec_eo/__init__.py",
    "chars": 69,
    "preview": "\"\"\"Module containing Gentec-eo instruments.\"\"\"\n\nfrom .blu import Blu\n"
  },
  {
    "path": "src/instruments/gentec_eo/blu.py",
    "chars": 20028,
    "preview": "\"\"\"Support for Gentec-EO Blu devices.\"\"\"\n\n# IMPORTS ####################################################################"
  },
  {
    "path": "src/instruments/glassman/__init__.py",
    "chars": 108,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Glassman power supplies\n\"\"\"\n\nfrom .glassmanfr import GlassmanFR\n"
  },
  {
    "path": "src/instruments/glassman/glassmanfr.py",
    "chars": 15958,
    "preview": "#!/usr/bin/env python\n#\n# hpe3631a.py: Driver for the Glassman FR Series Power Supplies\n#\n# © 2019 Francois Drielsma (fr"
  },
  {
    "path": "src/instruments/hcp/__init__.py",
    "chars": 126,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing HC Photonics instruments\n\"\"\"\n\nfrom .tc038 import TC038\nfrom .tc038d import T"
  },
  {
    "path": "src/instruments/hcp/tc038.py",
    "chars": 4609,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the TC038 AC crystal oven by HC Photonics.\n\"\"\"\n\n# IMPORTS ###############"
  },
  {
    "path": "src/instruments/hcp/tc038d.py",
    "chars": 5556,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the TC038 AC crystal oven by HC Photonics.\n\"\"\"\n\n# IMPORTS ###############"
  },
  {
    "path": "src/instruments/holzworth/__init__.py",
    "chars": 108,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Holzworth instruments\n\"\"\"\n\nfrom .holzworth_hs9000 import HS9000\n"
  },
  {
    "path": "src/instruments/holzworth/holzworth_hs9000.py",
    "chars": 8747,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Holzworth HS9000\n\"\"\"\n\n# IMPORTS #####################################"
  },
  {
    "path": "src/instruments/hp/__init__.py",
    "chars": 240,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing HP instruments\n\"\"\"\n\nfrom .hp3325a import HP3325a\nfrom .hp3456a import HP3456"
  },
  {
    "path": "src/instruments/hp/hp3325a.py",
    "chars": 7181,
    "preview": "#!/usr/bin/env python\n#\n# hp3325a.py: Driver for the HP3235a/b Synthesizer/Function Generator.\n#\n# © 2023 Scott Phillips"
  },
  {
    "path": "src/instruments/hp/hp3456a.py",
    "chars": 19387,
    "preview": "#!/usr/bin/env python\n#\n# hp3456a.py: Driver for the HP3456a Digital Voltmeter.\n#\n# © 2014 Willem Dijkstra (wpd@xs4all.n"
  },
  {
    "path": "src/instruments/hp/hp6624a.py",
    "chars": 10471,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the HP6624a power supply\n\"\"\"\n\n# IMPORTS #################################"
  },
  {
    "path": "src/instruments/hp/hp6632b.py",
    "chars": 14530,
    "preview": "#!/usr/bin/env python\n#\n# hp6632b.py: Python class for the HP6632b power supply\n#\n# © 2014 Willem Dijkstra (wpd@xs4all.n"
  },
  {
    "path": "src/instruments/hp/hp6652a.py",
    "chars": 6886,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDriver for the HP6652a single output power supply\n\nOriginally contributed by Wil Langford (wil"
  },
  {
    "path": "src/instruments/hp/hpe3631a.py",
    "chars": 8621,
    "preview": "#!/usr/bin/env python\n#\n# hpe3631a.py: Driver for the HP E3631A Power Supply\n#\n# © 2019 Francois Drielsma (francois.drie"
  },
  {
    "path": "src/instruments/keithley/__init__.py",
    "chars": 298,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Keithley instruments\n\"\"\"\n\nfrom .keithley195 import Keithley195\nfrom .keithle"
  },
  {
    "path": "src/instruments/keithley/keithley195.py",
    "chars": 12819,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDriver for the Keithley 195 digital multimeter\n\"\"\"\n\n# IMPORTS ################################"
  },
  {
    "path": "src/instruments/keithley/keithley2182.py",
    "chars": 7428,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDriver for the Keithley 2182 nano-voltmeter\n\"\"\"\n\n# IMPORTS ###################################"
  },
  {
    "path": "src/instruments/keithley/keithley485.py",
    "chars": 14268,
    "preview": "#!/usr/bin/env python\n#\n# keithley485.py: Driver for the Keithley 485 picoammeter.\n#\n# © 2019 Francois Drielsma (francoi"
  },
  {
    "path": "src/instruments/keithley/keithley580.py",
    "chars": 15926,
    "preview": "#!/usr/bin/env python\n#\n# keithley580.py: Driver for the Keithley 580 micro-ohmmeter.\n#\n# © 2013 Willem Dijkstra (wpd@xs"
  },
  {
    "path": "src/instruments/keithley/keithley6220.py",
    "chars": 2600,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Keithley 6220 constant current supply\n\"\"\"\n\n# IMPORTS ################"
  },
  {
    "path": "src/instruments/keithley/keithley6514.py",
    "chars": 6569,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Keithley 6514 electrometer\n\"\"\"\n\n# IMPORTS ###########################"
  },
  {
    "path": "src/instruments/lakeshore/__init__.py",
    "chars": 311,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Lakeshore instruments\n\"\"\"\n\nfrom instruments.lakeshore.lakeshore336 import La"
  },
  {
    "path": "src/instruments/lakeshore/lakeshore336.py",
    "chars": 2262,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Lakeshore Model 336 cryogenic temperature controller.\n\"\"\"\n\n# IMPORTS "
  },
  {
    "path": "src/instruments/lakeshore/lakeshore340.py",
    "chars": 2052,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Lakeshore 340 cryogenic temperature controller.\n\"\"\"\n\n# IMPORTS ######"
  },
  {
    "path": "src/instruments/lakeshore/lakeshore370.py",
    "chars": 2227,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Lakeshore 370 AC resistance bridge.\n\"\"\"\n\n# IMPORTS ##################"
  },
  {
    "path": "src/instruments/lakeshore/lakeshore475.py",
    "chars": 10839,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Lakeshore 475 Gaussmeter.\n\"\"\"\n\n# IMPORTS ############################"
  },
  {
    "path": "src/instruments/mettler_toledo/__init__.py",
    "chars": 104,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Mettler Toledo instruments\n\"\"\"\n\nfrom .mt_sics import MTSICS\n"
  },
  {
    "path": "src/instruments/mettler_toledo/mt_sics.py",
    "chars": 9838,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Mettler Toledo balances via Standard Interface Command Set.\n\"\"\"\n\nfrom"
  },
  {
    "path": "src/instruments/minghe/__init__.py",
    "chars": 98,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing MingHe instruments\n\"\"\"\n\nfrom .mhs5200a import MHS5200\n"
  },
  {
    "path": "src/instruments/minghe/mhs5200a.py",
    "chars": 6991,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides the support for the MingHe low-cost function generator.\n\nClass originally contributed"
  },
  {
    "path": "src/instruments/named_struct.py",
    "chars": 9795,
    "preview": "#!/usr/bin/env python\n\"\"\"\nClass for quickly defining C-like structures with named fields.\n\"\"\"\n\n# IMPORTS ###############"
  },
  {
    "path": "src/instruments/newport/__init__.py",
    "chars": 224,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Newport instruments\n\"\"\"\n\nfrom .agilis import AGUC2\n\nfrom .errors import Newp"
  },
  {
    "path": "src/instruments/newport/agilis.py",
    "chars": 18580,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Newport Agilis Controller AG-UC2 only (currently).\n\nAgilis controller"
  },
  {
    "path": "src/instruments/newport/errors.py",
    "chars": 6208,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides common error handling for Newport devices.\n\"\"\"\n\n# IMPORTS ###########################"
  },
  {
    "path": "src/instruments/newport/newport_pmc8742.py",
    "chars": 41128,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Newport Pico Motor Controller 8742\n\nNote that the class is currently "
  },
  {
    "path": "src/instruments/newport/newportesp301.py",
    "chars": 49328,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Newport ESP-301 motor controller.\n\nDue to the complexity of this piec"
  },
  {
    "path": "src/instruments/ondax/__init__.py",
    "chars": 86,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Ondax Instruments\n\"\"\"\n\nfrom .lm import LM\n"
  },
  {
    "path": "src/instruments/ondax/lm.py",
    "chars": 16223,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides the support for the Ondax LM Laser.\n\nClass originally contributed by Catherine Hollow"
  },
  {
    "path": "src/instruments/optional_dep_finder.py",
    "chars": 214,
    "preview": "\"\"\"\nSmall module to obtain handles to optional dependencies\n\"\"\"\n\n# pylint: disable=unused-import\ntry:\n    import numpy\n\n"
  },
  {
    "path": "src/instruments/oxford/__init__.py",
    "chars": 107,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Oxford instruments\n\"\"\"\n\nfrom .oxforditc503 import OxfordITC503\n"
  },
  {
    "path": "src/instruments/oxford/oxforditc503.py",
    "chars": 2112,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Oxford ITC 503 temperature controller.\n\"\"\"\n\n# IMPORTS ###############"
  },
  {
    "path": "src/instruments/pfeiffer/__init__.py",
    "chars": 97,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Pfeiffer instruments\n\"\"\"\n\nfrom .tpg36x import TPG36x\n"
  },
  {
    "path": "src/instruments/pfeiffer/tpg36x.py",
    "chars": 10929,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDriver for the Pfeiffer TPG36x vacumm gauge controller.\n\"\"\"\n\n# IMPORTS #######################"
  },
  {
    "path": "src/instruments/phasematrix/__init__.py",
    "chars": 126,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Phase Matrix instruments\n\"\"\"\n\nfrom .phasematrix_fsw0020 import PhaseMatrixFS"
  },
  {
    "path": "src/instruments/phasematrix/phasematrix_fsw0020.py",
    "chars": 4574,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Phase Matrix FSW0020 signal generator.\n\"\"\"\n\n# IMPORTS ###############"
  },
  {
    "path": "src/instruments/picowatt/__init__.py",
    "chars": 111,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Picowatt instruments\n\"\"\"\n\nfrom .picowattavs47 import PicowattAVS47\n"
  },
  {
    "path": "src/instruments/picowatt/picowattavs47.py",
    "chars": 4172,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Picowatt AVS 47 resistance bridge\n\"\"\"\n\n# IMPORTS ####################"
  },
  {
    "path": "src/instruments/qubitekk/__init__.py",
    "chars": 112,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Qubitekk instruments\n\"\"\"\n\nfrom .cc1 import CC1\nfrom .mc1 import MC1\n"
  },
  {
    "path": "src/instruments/qubitekk/cc1.py",
    "chars": 10527,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Qubitekk CC1 Coincidence Counter instrument.\n\nCC1 Class originally co"
  },
  {
    "path": "src/instruments/qubitekk/mc1.py",
    "chars": 7073,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Qubitekk MC1 Motor Controller.\n\nMC1 Class originally contributed by C"
  },
  {
    "path": "src/instruments/rigol/__init__.py",
    "chars": 110,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Rigol instruments\n\"\"\"\n\nfrom .rigolds1000 import RigolDS1000Series\n"
  },
  {
    "path": "src/instruments/rigol/rigolds1000.py",
    "chars": 6476,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for Rigol DS-1000 series oscilloscopes.\n\"\"\"\n\n# IMPORTS ######################"
  },
  {
    "path": "src/instruments/srs/__init__.py",
    "chars": 189,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Lakeshore instruments\n\"\"\"\n\nfrom .srs345 import SRS345\nfrom .srs830 import SR"
  },
  {
    "path": "src/instruments/srs/srs345.py",
    "chars": 2964,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the SRS 345 function generator.\n\"\"\"\n\n# IMPORTS ##########################"
  },
  {
    "path": "src/instruments/srs/srs830.py",
    "chars": 19002,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the SRS 830 lock-in amplifier.\n\"\"\"\n\n# IMPORTS ###########################"
  },
  {
    "path": "src/instruments/srs/srsctc100.py",
    "chars": 13265,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the SRS CTC-100 cryogenic temperature controller.\n\"\"\"\n\n# IMPORTS ########"
  },
  {
    "path": "src/instruments/srs/srsdg645.py",
    "chars": 11720,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the SRS DG645 digital delay generator.\n\"\"\"\n\n# IMPORTS ###################"
  },
  {
    "path": "src/instruments/sunpower/__init__.py",
    "chars": 104,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Sunpower instruments\n\"\"\"\n\nfrom .cryotel_gt import CryoTelGT\n"
  },
  {
    "path": "src/instruments/sunpower/cryotel_gt.py",
    "chars": 14383,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDriver for the Sunpower CryoTel GT generation 2 cryocooler.\n\"\"\"\n\n# IMPORTS ###################"
  },
  {
    "path": "src/instruments/tektronix/__init__.py",
    "chars": 244,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Tektronix instruments\n\"\"\"\n\nfrom .tekdpo4104 import TekDPO4104\nfrom .tekdpo70"
  },
  {
    "path": "src/instruments/tektronix/tekawg2000.py",
    "chars": 8359,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Tektronix AWG2000 series arbitrary wave generators.\n\"\"\"\n\n# IMPORTS ##"
  },
  {
    "path": "src/instruments/tektronix/tekdpo4104.py",
    "chars": 11794,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Tektronix DPO 4104 oscilloscope\n\"\"\"\n\n# IMPORTS ######################"
  },
  {
    "path": "src/instruments/tektronix/tekdpo70000.py",
    "chars": 26889,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Tektronix DPO 70000 oscilloscope series\n\"\"\"\n\n# IMPORTS ##############"
  },
  {
    "path": "src/instruments/tektronix/tektds224.py",
    "chars": 8667,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Tektronix TDS 224 oscilloscope\n\"\"\"\n\n# IMPORTS #######################"
  },
  {
    "path": "src/instruments/tektronix/tektds5xx.py",
    "chars": 19169,
    "preview": "#!/usr/bin/env python\n#\n# tektds5xx.py: Driver for the Tektronix TDS 5xx series oscilloscope.\n#\n# © 2014 Chris Schimp (s"
  },
  {
    "path": "src/instruments/teledyne/__init__.py",
    "chars": 93,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Teledyne instruments\n\"\"\"\n\nfrom .maui import MAUI\n"
  },
  {
    "path": "src/instruments/teledyne/maui.py",
    "chars": 47996,
    "preview": "#!/usr/bin/env python\n\"\"\"\nProvides support for the Teledyne-Lecroy Oscilloscopes that use the\nMAUI interface.\n\nDevelopme"
  },
  {
    "path": "src/instruments/thorlabs/__init__.py",
    "chars": 318,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule containing Thorlabs instruments\n\"\"\"\n\nfrom .thorlabsapt import (\n    ThorLabsAPT,\n    AP"
  },
  {
    "path": "src/instruments/thorlabs/_abstract.py",
    "chars": 3885,
    "preview": "#!/usr/bin/env python\n\"\"\"\nDefines a generic Thorlabs instrument to define some common functionality.\n\"\"\"\n\n# IMPORTS ####"
  },
  {
    "path": "src/instruments/thorlabs/_cmds.py",
    "chars": 8867,
    "preview": "#!/usr/bin/python\n\"\"\"\nContains command mneonics for the ThorLabs APT protocol\n\nClass originally contributed by Catherine"
  },
  {
    "path": "src/instruments/thorlabs/_packets.py",
    "chars": 5431,
    "preview": "#!/usr/bin/env python\n\"\"\"\nModule for working with ThorLabs packets.\n\"\"\"\n\n# IMPORTS #####################################"
  },
  {
    "path": "src/instruments/thorlabs/lcc25.py",
    "chars": 7209,
    "preview": "#!/usr/bin/python\n\"\"\"\nProvides the support for the Thorlabs LCC25 liquid crystal controller.\n\nClass originally contribut"
  }
]

// ... and 147 more files (download for full content)