[DEV] Python Driver code gen with ChatGPT.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "10bb3133",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "aaaacdce",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"OPENAI_API_KEY\"] = \"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\"\n",
    "os.environ[\n",
    "    \"AIRTABLE_API_KEY\"\n",
    "] = \"patRmmDLYqBiDx4Vx.a247028b00194b1a54e44d1ddf10f9fefe0e6cc59637c65f46e99241b5a8ca48\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a5a90c1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Qcodes Community', 'Instrumentkit', 'Pymeasure', 'Qcodes', '',\n",
       "       'Instrumental', 'Pytango'], dtype=object)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from load_data import load_data, Cols\n",
    "\n",
    "df = load_data()\n",
    "df[Cols.library].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16a76836-cddc-4670-9042-00fa3ae5fbd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Power Supplies']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for cat in df[Cols.category].tolist():\n",
    "    break\n",
    "cat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a700f7ce",
   "metadata": {},
   "source": [
    "# Instrumentkit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6bbf4e7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>Field 1</th>\n",
       "      <th>Vendor</th>\n",
       "      <th>Device</th>\n",
       "      <th>Library</th>\n",
       "      <th>Device Description</th>\n",
       "      <th>Python docs link</th>\n",
       "      <th>GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)</th>\n",
       "      <th>Corrected device name</th>\n",
       "      <th>Device picture</th>\n",
       "      <th>...</th>\n",
       "      <th>Category Description</th>\n",
       "      <th>Category description link</th>\n",
       "      <th>ChatGPT prompt</th>\n",
       "      <th>Image URL</th>\n",
       "      <th>Vendor logo URL</th>\n",
       "      <th>Device Price</th>\n",
       "      <th>ChatGPT code</th>\n",
       "      <th>Obsolete</th>\n",
       "      <th>QA Notes</th>\n",
       "      <th>docstring</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>606.0</td>\n",
       "      <td>Thorlabs</td>\n",
       "      <td>PM 100 USB</td>\n",
       "      <td>Instrumentkit</td>\n",
       "      <td>The PM100USB Power and Energy Meter Interface ...</td>\n",
       "      <td>https://instrumentkit.readthedocs.io/en/latest...</td>\n",
       "      <td>https://github.com/instrumentkit/InstrumentKit...</td>\n",
       "      <td>PM100USB</td>\n",
       "      <td>[OrderedDict([('id', 'attE3gJZRoLQpO3nR'), ('w...</td>\n",
       "      <td>...</td>\n",
       "      <td>These interfaces provide communication between...</td>\n",
       "      <td>https://www.thorlabs.com/newgrouppage9.cfm?obj...</td>\n",
       "      <td>Write a Python script that uses Instrumentkit ...</td>\n",
       "      <td>https://res.cloudinary.com/dhopxs1y3/image/upl...</td>\n",
       "      <td>https://res.cloudinary.com/dhopxs1y3/image/upl...</td>\n",
       "      <td>487.99</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>\\n\\nSource code for instruments.thorlabs.pm100...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>384.0</td>\n",
       "      <td>Newport</td>\n",
       "      <td>Picomotorcontroller 8742</td>\n",
       "      <td>Instrumentkit</td>\n",
       "      <td>The model 8742 is a 4-axis open-loop intellige...</td>\n",
       "      <td>https://instrumentkit.readthedocs.io/en/latest...</td>\n",
       "      <td>https://github.com/instrumentkit/InstrumentKit...</td>\n",
       "      <td>Picomotorcontroller 8742</td>\n",
       "      <td>[OrderedDict([('id', 'attloDMGvxGciAsjA'), ('w...</td>\n",
       "      <td>...</td>\n",
       "      <td>Motion control is a sub-field of automation, e...</td>\n",
       "      <td>https://en.wikipedia.org/wiki/Motion_control</td>\n",
       "      <td>Write a Python script that uses Instrumentkit ...</td>\n",
       "      <td>https://res.cloudinary.com/dhopxs1y3/image/upl...</td>\n",
       "      <td>https://res.cloudinary.com/dhopxs1y3/image/upl...</td>\n",
       "      <td>1260.00</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>\\n\\nSource code for instruments.newport.agilis...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 28 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Unnamed: 0  Field 1    Vendor                    Device        Library  \\\n",
       "0           2    606.0  Thorlabs                PM 100 USB  Instrumentkit   \n",
       "1           3    384.0   Newport  Picomotorcontroller 8742  Instrumentkit   \n",
       "\n",
       "                                  Device Description  \\\n",
       "0  The PM100USB Power and Energy Meter Interface ...   \n",
       "1  The model 8742 is a 4-axis open-loop intellige...   \n",
       "\n",
       "                                    Python docs link  \\\n",
       "0  https://instrumentkit.readthedocs.io/en/latest...   \n",
       "1  https://instrumentkit.readthedocs.io/en/latest...   \n",
       "\n",
       "  GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)  \\\n",
       "0  https://github.com/instrumentkit/InstrumentKit...          \n",
       "1  https://github.com/instrumentkit/InstrumentKit...          \n",
       "\n",
       "      Corrected device name  \\\n",
       "0                  PM100USB   \n",
       "1  Picomotorcontroller 8742   \n",
       "\n",
       "                                      Device picture  ...  \\\n",
       "0  [OrderedDict([('id', 'attE3gJZRoLQpO3nR'), ('w...  ...   \n",
       "1  [OrderedDict([('id', 'attloDMGvxGciAsjA'), ('w...  ...   \n",
       "\n",
       "                                Category Description  \\\n",
       "0  These interfaces provide communication between...   \n",
       "1  Motion control is a sub-field of automation, e...   \n",
       "\n",
       "                           Category description link  \\\n",
       "0  https://www.thorlabs.com/newgrouppage9.cfm?obj...   \n",
       "1       https://en.wikipedia.org/wiki/Motion_control   \n",
       "\n",
       "                                      ChatGPT prompt  \\\n",
       "0  Write a Python script that uses Instrumentkit ...   \n",
       "1  Write a Python script that uses Instrumentkit ...   \n",
       "\n",
       "                                           Image URL  \\\n",
       "0  https://res.cloudinary.com/dhopxs1y3/image/upl...   \n",
       "1  https://res.cloudinary.com/dhopxs1y3/image/upl...   \n",
       "\n",
       "                                     Vendor logo URL Device Price  \\\n",
       "0  https://res.cloudinary.com/dhopxs1y3/image/upl...       487.99   \n",
       "1  https://res.cloudinary.com/dhopxs1y3/image/upl...      1260.00   \n",
       "\n",
       "  ChatGPT code  Obsolete QA Notes  \\\n",
       "0          NaN       NaN      NaN   \n",
       "1          NaN       NaN      NaN   \n",
       "\n",
       "                                           docstring  \n",
       "0  \\n\\nSource code for instruments.thorlabs.pm100...  \n",
       "1  \\n\\nSource code for instruments.newport.agilis...  \n",
       "\n",
       "[2 rows x 28 columns]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "from scraping_utils import get_docs_from_link\n",
    "import pandas as pd\n",
    "\n",
    "if os.path.isfile(\"instrumentkit.csv\"):\n",
    "    df_inskit = pd.read_csv(\"instrumentkit.csv\")\n",
    "else:\n",
    "    df_inskit = df[df[Cols.library] == \"Instrumentkit\"]\n",
    "    if Cols.docstring not in df_inskit.columns:\n",
    "        df_inskit[Cols.docstring] = df_inskit[Cols.docs].map(get_docs_from_link)\n",
    "        df_inskit.to_csv(\"instrumentkit.csv\")\n",
    "\n",
    "df_inskit.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fbbd047b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: instrumentkit_snippets: File exists\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 67/67 [05:49<00:00,  5.22s/it]\n"
     ]
    }
   ],
   "source": [
    "!mkdir instrumentkit_snippets\n",
    "import numpy as np\n",
    "from tqdm.auto import tqdm\n",
    "from query_chatgpt import query_chatgpt\n",
    "import re\n",
    "\n",
    "for idx, row in tqdm(df_inskit.iterrows(), total=len(df_inskit)):\n",
    "    library = row[Cols.library]\n",
    "    device_name = row[Cols.device_name]\n",
    "    corrected = row[Cols.correct_device_name]\n",
    "    device = corrected if corrected is not np.nan else device_name\n",
    "\n",
    "    # Don't redo one that already exists\n",
    "    device_file = device.replace(\"/\", \"-\")\n",
    "    device_file = re.sub(r\"\\s+\", \"-\", device_file).strip(\"-\")\n",
    "    device_file = device_file.replace(\"&\", \"\")\n",
    "\n",
    "    device_path = f\"instrumentkit_snippets/{device_file}.txt\"\n",
    "    if os.path.isfile(device_path):\n",
    "        continue\n",
    "\n",
    "    category = row[Cols.category]\n",
    "    # For some reason they are formatted as '\"['text']\"'\n",
    "    category = eval(category)[0] if category is not np.nan else \"\"\n",
    "\n",
    "    docstring = row[Cols.docstring]\n",
    "    code = query_chatgpt(library, device, category, docstring)\n",
    "\n",
    "    with open(device_path, \"w\") as f:\n",
    "        f.write(code)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f9d55d0",
   "metadata": {},
   "source": [
    "# Qcodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3ba54bf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -qqq qcodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "676ea300",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/tp/gpgc4z156mb467qfgjc_ssr80000gn/T/ipykernel_64677/4207572633.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_qcodes[Cols.docstring] = df_qcodes[Cols.github_link].map(get_raw_code_for_device)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Device</th>\n",
       "      <th>Corrected device name</th>\n",
       "      <th>GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)</th>\n",
       "      <th>docstring</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Keysight 33511 B</td>\n",
       "      <td>Keysight 33511B</td>\n",
       "      <td>https://github.com/QCoDeS/Qcodes/blob/v0.25.0/...</td>\n",
       "      <td>from functools import partial\\nimport logging\\...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Lakeshore Model 372</td>\n",
       "      <td>Lakeshore Model 372</td>\n",
       "      <td>https://github.com/QCoDeS/Qcodes/blob/master/q...</td>\n",
       "      <td>from typing import Any, ClassVar\\n\\nimport qco...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Device Corrected device name  \\\n",
       "5     Keysight 33511 B       Keysight 33511B   \n",
       "9  Lakeshore Model 372   Lakeshore Model 372   \n",
       "\n",
       "  GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)  \\\n",
       "5  https://github.com/QCoDeS/Qcodes/blob/v0.25.0/...          \n",
       "9  https://github.com/QCoDeS/Qcodes/blob/master/q...          \n",
       "\n",
       "                                           docstring  \n",
       "5  from functools import partial\\nimport logging\\...  \n",
       "9  from typing import Any, ClassVar\\n\\nimport qco...  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from github_utils import get_raw_code_for_device\n",
    "\n",
    "if os.path.isfile(\"qcodes.csv\"):\n",
    "    df_qcodes = pd.read_csv(\"qcodes.csv\")\n",
    "else:\n",
    "    df_qcodes = df[df[Cols.library] == \"Qcodes\"]\n",
    "    if Cols.docstring not in df_qcodes.columns:\n",
    "        df_qcodes[Cols.docstring] = df_qcodes[Cols.github_link].map(\n",
    "            get_raw_code_for_device\n",
    "        )\n",
    "        df_qcodes.to_csv(\"qcodes.csv\")\n",
    "\n",
    "df_qcodes[\n",
    "    [Cols.device_name, Cols.correct_device_name, Cols.github_link, Cols.docstring]\n",
    "].head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7e2dc3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 126/126 [30:17<00:00, 14.42s/it] \n"
     ]
    }
   ],
   "source": [
    "from create_device_snippets import create_device_snippets\n",
    "\n",
    "create_device_snippets(df_qcodes, \"qcodes_snippets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34523c39",
   "metadata": {},
   "source": [
    "# PyTango"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1224cc51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 samples for Pytango\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/tp/gpgc4z156mb467qfgjc_ssr80000gn/T/ipykernel_64677/3639208470.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_tango[Cols.docstring] = df_tango[Cols.github_link].map(get_raw_code_for_device)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Device</th>\n",
       "      <th>Corrected device name</th>\n",
       "      <th>GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)</th>\n",
       "      <th>docstring</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>PH Photoncounter</td>\n",
       "      <td>PicoHarp 300</td>\n",
       "      <td>https://github.com/PicoQuant/PH300-v3.x-Demos/...</td>\n",
       "      <td># Demo for access to PicoHarp 300 Hardware via...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>Pipekeithley</td>\n",
       "      <td>Pipekeithley</td>\n",
       "      <td>http://svn.code.sf.net/p/tango-ds/code/DeviceC...</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Device Corrected device name  \\\n",
       "50   PH Photoncounter          PicoHarp 300   \n",
       "110      Pipekeithley          Pipekeithley   \n",
       "\n",
       "    GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)  \\\n",
       "50   https://github.com/PicoQuant/PH300-v3.x-Demos/...          \n",
       "110  http://svn.code.sf.net/p/tango-ds/code/DeviceC...          \n",
       "\n",
       "                                             docstring  \n",
       "50   # Demo for access to PicoHarp 300 Hardware via...  \n",
       "110                                                     "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from github_utils import get_raw_code_for_device\n",
    "\n",
    "if os.path.isfile(\"pytango.csv\"):\n",
    "    df_tango = pd.read_csv(\"pytango.csv\")\n",
    "else:\n",
    "    df_tango = df[df[Cols.library] == \"Pytango\"]\n",
    "    if Cols.docstring not in df_tango.columns:\n",
    "        df_tango[Cols.docstring] = df_tango[Cols.github_link].map(\n",
    "            get_raw_code_for_device\n",
    "        )\n",
    "        df_tango.to_csv(\"pytango.csv\")\n",
    "\n",
    "print(f\"{len(df_tango)} samples for Pytango\")\n",
    "df_tango[\n",
    "    [Cols.device_name, Cols.correct_device_name, Cols.github_link, Cols.docstring]\n",
    "].head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9d820e32",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 11/11 [01:57<00:00, 10.66s/it]\n"
     ]
    }
   ],
   "source": [
    "from create_device_snippets import create_device_snippets\n",
    "\n",
    "create_device_snippets(df_tango, \"pytango_snippets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134f8ee7",
   "metadata": {},
   "source": [
    "# Pymeasure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0801e651",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] Converting notebook /var/folders/tp/gpgc4z156mb467qfgjc_ssr80000gn/T/tmpikn1azdz/device.ipynb to script\n",
      "/Users/nick/.pyenv/versions/3.10.11/share/jupyter/nbconvert/templates/python/index.py.j2:61: UserWarning: IPython is needed to transform IPython syntax to pure Python. Install ipython if you need this functionality.\n",
      "[NbConvertApp] Writing 34206 bytes to /var/folders/tp/gpgc4z156mb467qfgjc_ssr80000gn/T/tmpikn1azdz/device.py\n",
      "/var/folders/tp/gpgc4z156mb467qfgjc_ssr80000gn/T/ipykernel_64677/316810200.py:10: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df_measure[Cols.docstring] = df_measure[Cols.github_link].map(get_raw_code_for_device)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Device</th>\n",
       "      <th>Corrected device name</th>\n",
       "      <th>GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)</th>\n",
       "      <th>docstring</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Lakeshore 421</td>\n",
       "      <td>Lakeshore 421</td>\n",
       "      <td>https://github.com/pymeasure/pymeasure/blob/ma...</td>\n",
       "      <td>#\\n# This file is part of the PyMeasure packag...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>SR 570</td>\n",
       "      <td>SR 570</td>\n",
       "      <td>https://github.com/pymeasure/pymeasure/blob/ma...</td>\n",
       "      <td>#\\n# This file is part of the PyMeasure packag...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          Device Corrected device name  \\\n",
       "4  Lakeshore 421         Lakeshore 421   \n",
       "6         SR 570                SR 570   \n",
       "\n",
       "  GitHub link to Python driver (NOT LINK TO DOCS ON GITHUB)  \\\n",
       "4  https://github.com/pymeasure/pymeasure/blob/ma...          \n",
       "6  https://github.com/pymeasure/pymeasure/blob/ma...          \n",
       "\n",
       "                                           docstring  \n",
       "4  #\\n# This file is part of the PyMeasure packag...  \n",
       "6  #\\n# This file is part of the PyMeasure packag...  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from github_utils import get_raw_code_for_device\n",
    "\n",
    "if os.path.isfile(\"pymeasure.csv\"):\n",
    "    df_measure = pd.read_csv(\"pymeasure.csv\")\n",
    "else:\n",
    "    df_measure = df[df[Cols.library] == \"Pymeasure\"]\n",
    "    if Cols.docstring not in df_measure.columns:\n",
    "        df_measure[Cols.docstring] = df_measure[Cols.github_link].map(\n",
    "            get_raw_code_for_device\n",
    "        )\n",
    "        df_measure.to_csv(\"pymeasure.csv\")\n",
    "\n",
    "df_measure[\n",
    "    [Cols.device_name, Cols.correct_device_name, Cols.github_link, Cols.docstring]\n",
    "].head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "9212103c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 73/73 [21:14<00:00, 17.46s/it]\n"
     ]
    }
   ],
   "source": [
    "from create_device_snippets import create_device_snippets\n",
    "\n",
    "create_device_snippets(df_measure, \"pymeasure_snippets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c12fe3c3",
   "metadata": {},
   "source": [
    "# Debugging decoding/counting tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cd3ca6bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'# -*- coding: utf-8 -*-\\n\\n########################## Copyrights and license ############################\\n#                                                                            #\\n# Copyright 2011-2015  Christian Lupien <christian.lupien@usherbrooke.ca>    #\\n#                                                                            #\\n# This file is part of pyHegel.  http://github.com/lupien/pyHegel            #\\n#                                                                            #\\n# pyHegel is free software: you can redistribute it and/or modify it under   #\\n# the terms of the GNU Lesser General Public License as published by the     #\\n# Free Software Foundation, either version 3 of the License, or (at your     #\\n# option) any later version.                                                 #\\n#                                                                            #\\n# pyHegel is distributed in the hope that it will be useful, but WITHOUT     #\\n# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or      #\\n# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public        #\\n# License for more details.                                                  #\\n#                                                                            #\\n# You should have received a copy of the GNU Lesser General Public License   #\\n# along with pyHegel.  If not, see <http://www.gnu.org/licenses/>.           #\\n#                                                                            #\\n##############################################################################\\n\\nfrom __future__ import absolute_import\\n\\nimport numpy as np\\nimport scipy\\nimport os.path\\n\\nfrom ..instruments_base import visaInstrument, visaInstrumentAsync,\\\\\\n                            BaseDevice, scpiDevice, MemoryDevice, ReadvalDev,\\\\\\n                            ChoiceMultiple, Choice_bool_OnOff, _repr_or_string,\\\\\\n                            quoted_string, quoted_list, quoted_dict, ChoiceLimits,\\\\\\n                            ChoiceStrings, ChoiceDevDep, ChoiceDev, ChoiceDevSwitch, ChoiceIndex,\\\\\\n                            decode_float64, decode_float64_avg, decode_float64_meanstd,\\\\\\n                            decode_uint16_bin, _decode_block_base, decode_float64_2col,\\\\\\n                            decode_complex128, sleep, locked_calling, visa_wrap, _encode_block\\nfrom ..instruments_registry import register_instrument, register_usb_name, register_idn_alias\\n\\nregister_usb_name(\\'Agilent Technologies\\', 0x0957)\\n\\n#######################################################\\n##    Agilent RF 33522A generator\\n#######################################################\\n\\n#@register_instrument(\\'Agilent Technologies\\', \\'33522A\\', \\'1.10-1.19-1.01-45-00\\')\\n#@register_instrument(\\'Agilent Technologies\\', \\'33522A\\', \\'1.11-1.19-1.01-46-00\\')\\n#@register_instrument(\\'Agilent Technologies\\', \\'33522A\\', \\'1.12-1.19-1.01-50-00\\')\\n#@register_instrument(\\'Agilent Technologies\\', \\'33522A\\', \\'2.01-1.19-2.00-52-00\\')\\n@register_instrument(\\'Agilent Technologies\\', \\'33522A\\', usb_vendor_product=[0x0957, 0x2307], alias=\\'33522A RF generator\\')\\nclass agilent_rf_33522A(visaInstrument):\\n    \"\"\"\\n    New code should use the unumbered devices (numbered device are there for compatibility.)\\n    The devices\\n    \"\"\"\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        opts = [\\'opt=%s\\'%self.available_options]\\n        opts += self._conf_helper(\\'ref_oscillator_current_state\\', \\'coupled_ampl_en\\', \\'coupled_freq_en\\')\\n        if self.coupled_freq_en.getcache():\\n            opts += self._conf_helper(\\'coupled_freq_mode\\')\\n            if self.coupled_freq_mode.getcache().upper().startswith(\\'OFF\\'):\\n                opts += self._conf_helper(\\'coupled_freq_offset\\')\\n            else:\\n                opts += self._conf_helper(\\'coupled_freq_ratio\\')\\n        curr_ch = self.current_ch.getcache()\\n        ch = options.get(\\'ch\\', None)\\n        if ch is not None:\\n            self.current_ch.set(ch)\\n        opts += self._conf_helper(\\'current_ch\\', \\'out_en\\', \\'ampl\\', \\'ampl_autorange_en\\', \\'ampl_unit\\', \\'offset\\',\\n                                  \\'volt_limit_low\\', \\'volt_limit_high\\', \\'volt_limit_en\\', \\'out_load_ohm\\', \\'out_polarity\\',\\n                                  \\'freq\\', \\'freq_mode\\', \\'phase\\', \\'mode\\', \\'noise_bw\\', \\'pulse_width\\',\\n                                  \\'mod_am_en\\', \\'mod_am_depth_pct\\', \\'mod_am_dssc_en\\', \\'mod_am_src\\', \\'mod_am_int_func\\', \\'mod_am_int_freq\\',\\n                                  \\'mod_fm_en\\', \\'mod_phase_en\\')\\n        self.current_ch.set(curr_ch)\\n        return opts + self._conf_helper(options)\\n    def _create_devs(self):\\n        opt = self.ask(\\'*OPT?\\')\\n        opt = opt.split(\\',\\')\\n        if opt[0] == \\'010\\':\\n            tb = \\'oven\\'\\n        else:\\n            tb = \\'standard\\'\\n        if opt[1] == \\'002\\':\\n            extmem = True\\n        else:\\n            extmem = False\\n        if opt[2] == \\'400\\':\\n            gpib_avail = True\\n        else:\\n            gpib_avail = False\\n        self.available_options = {\\'time_base\\': tb}\\n        self.available_options[\\'extended_mem\\'] = extmem\\n        self.available_options[\\'gpib_installed\\'] = gpib_avail\\n        self.ref_oscillator = scpiDevice(\\'ROSCillator:SOURce\\', choices=ChoiceStrings(\\'INTernal\\', \\'EXTernal\\'))\\n        # This is a weird one. It does not use 0 or 1 like most others. It only accepts ON or OFF\\n        self.ref_oscillator_auto_en = scpiDevice(\\'ROSCillator:SOURce:AUTO\\', choices=Choice_bool_OnOff)\\n        self.ref_oscillator_current_state = scpiDevice(getstr=\\'ROSCillator:SOURce:CURRent?\\', choices=ChoiceStrings(\\'INTernal\\', \\'EXTernal\\'))\\n        # new interface\\n        self.current_ch = MemoryDevice(1, min=1, max=2)\\n        def devChOption(*arg, **kwarg):\\n            options = kwarg.pop(\\'options\\', {}).copy()\\n            options.update(ch=self.current_ch)\\n            app = kwarg.pop(\\'options_apply\\', [\\'ch\\'])\\n            kwarg.update(options=options, options_apply=app)\\n            return scpiDevice(*arg, **kwarg)\\n        self.coupled_ampl_en = devChOption(\\'SOURce{ch}:VOLTage:COUPle\\', str_type=bool)\\n        self.ampl = devChOption(\\'SOURce{ch}:VOLTage\\', str_type=float, setget=True, doc=\"\"\"Minimum is 1 mVpp. Maximum = 10 Vpp. See ampl_unit device for unit type (Vrms, Vpp or dBm)\"\"\")\\n        self.ampl_autorange_en = devChOption(\\'SOURce{ch}:VOLTage:RANGe:AUTO\\', str_type=bool, doc=\"When False, disables the automatic attenuator change.\")\\n        self.offset = devChOption(\\'SOURce{ch}:VOLTage:OFFSet\\', str_type=float, setget=True, doc=\"\"\"Minimum is -5 V, Maximum = 5 V (but can be smaller because of ampl).\"\"\")\\n        self.ampl_unit = devChOption(\\'SOURce{ch}:VOLTage:UNIT\\', choices=ChoiceStrings(\\'VPP\\', \\'VRMS\\', \\'DBM\\'))\\n        self.volt_limit_low = devChOption(\\'SOURce{ch}:VOLTage:LIMit:LOW\\', str_type=float, setget=True, doc=\"\"\"Output will not go below this voltage, if limit is enabled.\"\"\")\\n        self.volt_limit_high = devChOption(\\'SOURce{ch}:VOLTage:LIMit:HIGH\\', str_type=float, setget=True, doc=\"\"\"Output will not go above this voltage, if limit is enabled.\"\"\")\\n        self.volt_limit_en = devChOption(\\'SOURce{ch}:VOLTage:LIMit:STATe\\', str_type=bool)\\n        self.coupled_freq_en = devChOption(\\'SOURce{ch}:FREQuency:COUPle\\', str_type=bool)\\n        self.coupled_freq_mode = devChOption(\\'SOURce{ch}:FREQuency:COUPle:MODE\\', choices=ChoiceStrings(\\'OFFSet\\', \\'RATio\\'))\\n        self.coupled_freq_offset = devChOption(\\'SOURce{ch}:FREQuency:COUPle:OFFSet\\', str_type=float, setget=True)\\n        self.coupled_freq_ratio = devChOption(\\'SOURce{ch}:FREQuency:COUPle:RATio\\', str_type=float, setget=True)\\n        self.freq = devChOption(\\'SOURce{ch}:FREQuency\\', str_type=float, setget=True, min=1e-6, max=30e6)\\n        # TODO handle sweep and list\\n        self.freq_mode = devChOption(\\'SOURce{ch}:FREQuency:MODE\\', choices=ChoiceStrings(\\'CW\\',\\'LIST\\',\\'SWEep\\',\\'FIXed\\'), doc=\\'CW and FIXED are the same. SWEep and List are not handled currently.\\')\\n        self.phase = devChOption(\\'SOURce{ch}:PHASe\\', str_type=float, setget=True, min=-360, max=360, doc=\\'Angle in degrees\\')\\n        self.mode = devChOption(\\'SOURce{ch}:FUNCtion\\', choices=ChoiceStrings(\\'SINusoid\\', \\'SQUare\\', \\'RAMP\\', \\'PULSe\\', \\'PRBS\\', \\'NOISe\\', \\'ARB\\', \\'DC\\'))\\n        self.noise_bw = devChOption(\\'SOURce{ch}:FUNCtion:NOISe:BANDwidth\\', str_type=float, setget=True, min=0.001, max=30e6)\\n        self.pulse_width = devChOption(\\'SOURce{ch}:FUNCtion:PULSe:WIDTh\\', str_type=float, min=16e-9, max=1e6) # s\\n        self.out_en = devChOption(\\'OUTPut{ch}\\', str_type=bool)\\n        self.out_load_ohm = devChOption(\\'OUTPut{ch}:LOAD\\', str_type=float, setget=True, min=1, doc=\"max is 10 kOhm. For High impedance (INFinity) use 9.9e37\")\\n        self.out_polarity = devChOption(\\'OUTPut{ch}:POLarity\\', choices=ChoiceStrings(\\'NORMal\\', \\'INVerted\\'))\\n        # Modulations parameters  TODO  missing modulations are BPSK FSKey PWM\\n        self.mod_am_en = devChOption(\\'SOURce{ch}:AM:STATe\\', str_type=bool)\\n        self.mod_am_depth_pct = devChOption(\\'SOURce{ch}:AM:DEPTh\\', str_type=float, min=0, max=120, setget=True)\\n        self.mod_am_dssc_en = devChOption(\\'SOURce{ch}:AM:DSSC\\', str_type=bool, doc=\"DSSC = Double Sideband Suppressed Carrier\")\\n        self.mod_am_src = devChOption(\\'SOURce{ch}:AM:SOURce\\', choices=ChoiceStrings(\\'INTernal\\', \\'EXTernal\\', \\'CH1\\', \\'CH2\\'), doc=\\'External input is +- 5V\\')\\n        self.mod_am_int_func = devChOption(\\'SOURce{ch}:AM:INTernal:FUNCtion\\', choices=ChoiceStrings(\\'SINusoid\\', \\'SQUare\\', \\'RAMP\\', \\'NRAMp\\', \\'TRIangle\\', \\'NOISe\\', \\'PRBS\\', \\'ARB\\'))\\n        self.mod_am_int_freq = devChOption(\\'SOURce{ch}:AM:INTernal:FREQuency\\', str_type=float, min=1e-6, setget=True)\\n\\n        self.mod_fm_en = devChOption(\\'SOURce{ch}:FM:STATe\\', str_type=bool)\\n        self.mod_phase_en = devChOption(\\'SOURce{ch}:PM:STATe\\', str_type=bool)\\n\\n        # Older interface\\n        # voltage unit depends on front panel/remote selection (sourc1:voltage:unit) vpp, vrms, dbm\\n        self.ampl1 = scpiDevice(\\'SOUR1:VOLT\\', str_type=float, min=0.001, max=10)\\n        self.freq1 = scpiDevice(\\'SOUR1:FREQ\\', str_type=float, min=1e-6, max=30e6)\\n        self.pulse_width1 = scpiDevice(\\'SOURce1:FUNCtion:PULSe:WIDTh\\', str_type=float, min=16e-9, max=1e6) # s\\n        self.offset1 = scpiDevice(\\'SOUR1:VOLT:OFFS\\', str_type=float, min=-5, max=5)\\n        self.phase1 = scpiDevice(\\'SOURce1:PHASe\\', str_type=float, min=-360, max=360) # in deg unless changed by unit:angle\\n        self.mode1 = scpiDevice(\\'SOUR1:FUNC\\') # SIN, SQU, RAMP, PULS, PRBS, NOIS, ARB, DC\\n        self.out_en1 = scpiDevice(\\'OUTPut1\\', str_type=bool) #OFF,0 or ON,1\\n        self.ampl2 = scpiDevice(\\'SOUR2:VOLT\\', str_type=float, min=0.001, max=10)\\n        self.freq2 = scpiDevice(\\'SOUR2:FREQ\\', str_type=float, min=1e-6, max=30e6)\\n        self.pulse_width2 = scpiDevice(\\'SOURce2:FUNCtion:PULSe:WIDTh\\', str_type=float, min=16e-9, max=1e6) # s\\n        self.phase2 = scpiDevice(\\'SOURce2:PHASe\\', str_type=float, min=-360, max=360) # in deg unless changed by unit:angle\\n        self.offset2 = scpiDevice(\\'SOUR2:VOLT:OFFS\\', str_type=float, min=-5, max=5)\\n        self.mode2 = scpiDevice(\\'SOUR2:FUNC\\') # SIN, SQU, RAMP, PULS, PRBS, NOIS, ARB, DC\\n        self.out_en2 = scpiDevice(\\'OUTPut2\\', str_type=bool) #OFF,0 or ON,1\\n        self.alias = self.freq\\n        # This needs to be last to complete creation\\n        super(type(self),self)._create_devs()\\n    def phase_sync(self):\\n        self.write(\\'PHASe:SYNChronize\\')\\n    def phase_ref(self, ch=None):\\n        if ch is not None:\\n            self.current_ch.set(ch)\\n        ch=self.current_ch.getcache()\\n        self.write(\\'SOURce{ch}:PHASe:REFerence\\'.format(ch=ch))\\n\\n\\n#######################################################\\n##    Agilent EPM power meter\\n#######################################################\\n\\n#@register_instrument(\\'Agilent Technologies\\', \\'N1913A\\', \\'A1.01.07\\')\\n@register_instrument(\\'Agilent Technologies\\', \\'N1913A\\', usb_vendor_product=[0x0957, 0x5418], alias=\\'N1913A EPM power meter\\')\\nclass agilent_PowerMeter(visaInstrumentAsync):\\n    \"\"\"\\n    This instrument is for Agilent N1913A EPM seris power meter with a N8487A\\n    average power sensor.\\n\\n    Get data with readval (force read of new data) or fetch (gets possibly old data)\\n    Note that only the upper display upper line is read.\\n\\n    gain_ch_{dB,en} applies a correction to the channel data.\\n    gain_{dB,en} applies a correction to the display (measurement menu)\\n                 (goes with relative menu)\\n    cset1_en is for manual sensor calibration (cannot be turn on for our sensor\\n             because it already provides a calibration, see th CF percent value on the\\n             display that depends on frequency. It is 100% at 50 MHz)\\n    cset2_en is a second manual calibration (called FDO table in channel/offsets)\\n             to compensate for the circuit used. It also depends on the frequency.\\n             You can read this correction value with freq_offset\\n    \"\"\"\\n    # As of (firmware A1.01.07) the relative value cannot be read.\\n    # The instrument has 4 display position (top upper, top lower, ...)\\n    #  1=upper window upper meas, 2=lower upper, 3=upper lower, 4=lower lower\\n    # They are not necessarily active on the display but they are all used for\\n    # average calculation and can all be used for reading data.\\n    def __init__(self, visa_addr):\\n        # The SRQ for this intrument only works on gpib\\n        # for lan or usb we need to revert to polling.\\n        # That is because the read_status_byte seems to always return 0\\n        # in those cases. So we use *stb? and polling instead.\\n        self._status_use_stb = False # Used for init\\n        super(agilent_PowerMeter, self).__init__(visa_addr, poll=\\'not_gpib\\')\\n        if self._async_polling:\\n            self._status_use_stb = True\\n    def read_status_byte(self):\\n        if self._status_use_stb:\\n            return int(self.ask(\\'*STB?\\'))\\n        else:\\n            return super(agilent_PowerMeter, self).read_status_byte()\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        return self._conf_helper(\\'range\\', \\'range_auto_en\\', \\'unit\\',\\n                                 \\'gain_en\\', \\'hold_mode\\', \\'relative_en\\', \\'average_en\\',\\n                                 \\'average_cnt\\', \\'average_cnt_auto\\', \\'average_step_detection\\',\\n                                 \\'cset1_en\\', \\'cset2_en\\', \\'trig_src\\',\\n                                 \\'sensor_calib_date\\', \\'sensor_type\\', \\'sensor_serialno\\',\\n                                 \\'linear_corr_type\\', \\'meas_rate\\',\\n                                 \\'gain_ch_dB\\', \\'gain_ch_en\\',\\n                                 \\'duty_cycle_percent\\', \\'duty_cycle_en\\',\\n                                 \\'freq\\', \\'freq_offset\\', \\'freq_offset_unit\\',\\n                                 options)\\n    @locked_calling\\n    def _async_trig(self):\\n        self.trig_delay_en.set(True)\\n        self.cont_trigger.set(False)\\n        super(agilent_PowerMeter, self)._async_trig()\\n    def set_relative(self):\\n        self.write(\\'CALCulate1:RELative:AUTO ONCE\\')\\n    def _create_devs(self):\\n        # voltage unit depends on front panel/remote selection (sourc1:voltage:unit) vpp, vrms, dbm\\n        self.range = scpiDevice(\\'SENSe:POWer:AC:RANGe\\', str_type=int, min=0, max=1)\\n        self.config = scpiDevice(\\'CONFigure1\\')\\n        #self.resolution = scpiDevice(\\'CONFig1 DEF,{val}\\', str_type=int, min=1, max=4)\\n        self.resolution = scpiDevice(\\'DISPlay:WINDow1:NUMeric1:RESolution\\', str_type=int, min=1, max=4)\\n        self.range_auto_en = scpiDevice(\\'SENSe:POWer:AC:RANGe:AUTO\\', str_type=bool)\\n        self.unit = scpiDevice(\\'UNIT:POWer\\', choices=ChoiceStrings(\\'DBM\\', \\'W\\'))\\n        self.gain_dB = scpiDevice(\\'CALCulate1:GAIN\\', str_type=float, min=-100, max=100)\\n        self.gain_en = scpiDevice(\\'CALCulate1:GAIN:STATe\\', str_type=bool)\\n        self.hold_mode = scpiDevice(\\'CALCulate1:HOLD:STAT\\', choices=ChoiceStrings(\\'OFF\\', \\'MIN\\', \\'MAX\\'))\\n        self.relative_en = scpiDevice(\\'CALCulate1:RELative:STATe\\', str_type=bool)\\n        #SENSE subsystem\\n        self.average_cnt = scpiDevice(\\'AVERage:COUNt\\', str_type=int, min=1, max=1024)\\n        self.average_cnt_auto = scpiDevice(\\'AVERage:COUNt:AUTO\\', str_type=bool)\\n        self.average_step_detection = scpiDevice(\\'AVERage:SDETect\\', str_type=bool)\\n        self.average_en = scpiDevice(\\'AVERage\\', str_type=bool)\\n        #self.gain_factor_pct = scpiDevice(\\'CORRection:CFACtor\\', str_type=float, min=1., max=150.)\\n        self.cset1_en = scpiDevice(\\'CORRection:CSET1:STATe\\', str_type=bool)\\n        self.cset2_en = scpiDevice(\\'CORRection:CSET2:STATe\\', str_type=bool)\\n        self.freq = scpiDevice(\\'FREQuency\\', str_type=float, min=1e3, max=1e12)\\n        self.freq_offset = scpiDevice(getstr=\\'CORRection:FDOFfset?\\', str_type=float)\\n        self.freq_offset_unit = scpiDevice(\\'CORRection:FDOFfset:UNIT\\', choices=ChoiceStrings(\\'PCT\\', \\'DB\\'))\\n        self.duty_cycle_percent = scpiDevice(\\'CORRection:DCYCle\\', str_type=float, min=.001, max=99.999)\\n        self.duty_cycle_en = scpiDevice(\\'CORRection:DCYCle:STATe\\', str_type=bool)\\n        self.gain_ch_dB = scpiDevice(\\'CORRection:GAIN2\\', str_type=float, min=-100, max=100)\\n        self.gain_ch_en = scpiDevice(\\'CORRection:GAIN2:STATe\\', str_type=bool)\\n        self.meas_rate = scpiDevice(\\'MRATe\\', choices=ChoiceStrings(\\'NORMal\\', \\'DOUBle\\', \\'FAST\\'))\\n        self.linear_corr_type = scpiDevice(\\'V2P\\', choices=ChoiceStrings(\\'ATYPe\\', \\'DTYPe\\'))\\n        self.sensor_calib_date = scpiDevice(getstr=\\'SERVice:SENSor:CDATe?\\')\\n        self.sensor_calib_place = scpiDevice(getstr=\\'SERVice:SENSor:CPLace?\\')\\n        self.sensor_type = scpiDevice(getstr=\\'SERVice:SENSor:TYPE?\\')\\n        self.sensor_serialno = scpiDevice(getstr=\\'SERVice:SENSor:SNUMber?\\')\\n        self.raw_reading = scpiDevice(getstr=\\'SERVice:SENSor:RADC?\\', autoinit=False, trig=True)\\n        #TRIGGER block\\n        self.trig_src = scpiDevice(\\'TRIGger:SOURce\\', choices=ChoiceStrings(\\'BUS\\', \\'EXTernal\\', \\'HOLD\\', \\'IMMediate\\'))\\n        self.trig_delay_en = scpiDevice(\\'TRIGger:DELay:AUTO\\', str_type=bool)\\n        self.cont_trigger = scpiDevice(\\'INITiate:CONTinuous\\', str_type=bool)\\n        #READ, FETCH\\n        self.fetch = scpiDevice(getstr=\\'FETCh?\\',str_type=float, autoinit=False, trig=True) #You need to read some data first.\\n        self.readval = ReadvalDev(self.fetch)\\n        self.alias = self.readval\\n        # This needs to be last to complete creation\\n        super(type(self),self)._create_devs()\\n\\n\\n#######################################################\\n##    Agilent PSG generator\\n#######################################################\\n\\n#@register_instrument(\\'Agilent Technologies\\', \\'E8257D\\', \\'C.06.16\\')\\n@register_instrument(\\'Agilent Technologies\\', \\'E8257D\\', alias=\\'E8257D PSG Generator\\')\\nclass agilent_rf_PSG(visaInstrument):\\n    \"\"\"\\n    This controls a PSG signal generetor\\n    Most useful devices:\\n        ampl\\n        ampl_unit\\n        rf_en\\n        mod_en\\n        freq_cw\\n    The alc devices refer to automatic level (amplitude) control.\\n    Available methods:\\n        phase_sync\\n    \"\"\"\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        # TODO Get the proper config\\n        return self._conf_helper(\\'oscillator_source\\', \\'rf_en\\', \\'ampl\\', \\'ampl_unit\\', \\'amp_flatness_corr_en\\',\\n                                 \\'ampl_offset_db\\', \\'ampl_reference_dbm\\', \\'ampl_reference_en\\',\\n                                 \\'ampl_protection\\', \\'ampl_mode\\', \\'ampl_start\\', \\'ampl_stop\\',\\n                                 \\'alc_en\\', \\'alc_source\\', \\'alc_bw\\', \\'alc_bw_auto_en\\',\\n                                 \\'attenuation_db\\', \\'attenuation_auto_en\\', \\'amp_flatness_corr_en\\',\\n                                 \\'output_blanking_en\\', \\'output_blanking_auto_en\\',\\n                                 \\'freq_mode\\', \\'freq_cw\\', \\'freq_start\\', \\'freq_stop\\',\\n                                 \\'freq_multiplier\\', \\'freq_offset\\', \\'freq_offset_en\\', \\'freq_reference\\', \\'freq_reference_en\\',\\n                                 \\'phase\\', \\'mod_en\\', \\'mod_am_en\\', \\'mod_fm_en\\', \\'mod_phase_en\\', \\'mod_pulse_en\\',\\n                                 \\'mod_am_freq\\', \\'mod_am_shape\\', \\'mod_am_depth\\',\\'mod_am_noise_type\\',\\n                                 \\'mod_pulse_period\\', \\'mod_pulse_width\\', options)\\n    def _create_devs(self):\\n        self.installed_options = scpiDevice(getstr=\\'*OPT?\\')\\n        self.oscillator_source = scpiDevice(getstr=\\':ROSCillator:SOURce?\\', str_type=str)\\n        self.rf_en = scpiDevice(\\':OUTPut\\', str_type=bool)\\n        self.ampl = scpiDevice(\\':POWer\\', str_type=float, doc=\\'unit depends on device ampl_unit\\', setget=True)\\n        self.ampl_unit = scpiDevice(\\':UNIT:POWer\\', choices=ChoiceStrings(\\'DBM\\', \\'DBUV\\', \\'DBUVEMF\\', \\'V\\', \\'VEMF\\', \\'DB\\'),\\n                                    doc=\\'Note that EMF are 2x above the base unit (power arriving at infinite impedance load)\\')\\n        # unit:volt:type affects volt scale like power:alc:search:ref:level, which are not user changeable\\n        self.ampl_offset_db = scpiDevice(\\':POWer:OFFset\\', str_type=float, min=-200, max=+200)\\n        self.ampl_reference_dbm = scpiDevice(\\':POWer:REFerence\\', str_type=float, doc=\\'This value is always in dBm\\')\\n        self.ampl_reference_en = scpiDevice(\\':POWer:REFerence:STATe\\', str_type=bool)\\n        self.ampl_mode = scpiDevice(\\':POWer:MODE\\', choices=ChoiceStrings(\\'FIXed\\', \\'LIST\\'))\\n        #self.ampl_optimize_lownoise = scpiDevice(\\':POWer:NOISe\\', str_type=bool)\\n        self.ampl_protection = scpiDevice(\\':POWer:PROTection\\', str_type=bool, doc=\\'When enabled, sets the attenuation to maximum when performing a power search. Could decrease the life of the attenuator.\\')\\n        self.ampl_start = scpiDevice(\\':POWer:STARt\\', str_type=float, doc=\\'unit depends on device ampl_unit\\', setget=True)\\n        self.ampl_stop = scpiDevice(\\':POWer:STOP\\', str_type=float, doc=\\'unit depends on device ampl_unit\\', setget=True)\\n        # TODO handle the search stuff for when alc is off\\n        self.alc_en = scpiDevice(\\':POWer:ALC\\', str_type=bool)\\n        self.alc_source = scpiDevice(\\':POWer:ALC:SOURce\\', choices=ChoiceStrings(\\'INTernal\\', \\'DIODe\\'))\\n        # The alc_bw don\\'t seem to have a front panel control. It might not do anything for the\\n        # generator N5183A we used.\\n        self.alc_bw = scpiDevice(\\':POWer:ALC:BANDwidth\\', str_type=float)\\n        self.alc_bw_auto_en = scpiDevice(\\':POWer:ALC:BANDwidth:AUTO\\', str_type=bool)\\n        self.attenuation_db = scpiDevice(\\':POWer:ATTenuation\\', str_type=float, min=0, max=15, setget=True)\\n        self.attenuation_auto_en = scpiDevice(\\':POWer:ATTenuation:AUTO\\', str_type=bool)\\n        self.amp_flatness_corr_en = scpiDevice(\\':CORRection\\', str_type=bool)\\n        self.output_blanking_en = scpiDevice(\\':OUTPut:BLANKing:STATe\\', str_type=bool)\\n        self.output_blanking_auto_en = scpiDevice(\\':OUTPut:BLANKing:AUTO\\', str_type=bool)\\n        self.freq_mode = scpiDevice(\\':FREQuency:MODE\\', choices=ChoiceStrings(\\'CW\\', \\'FIXed\\', \\'LIST\\'), doc=\\'CW and FIXed are the same, LIST means sweeping\\')\\n        minfreq = float(self.ask(\\':FREQ? min\\'))\\n        maxfreq = float(self.ask(\\':FREQ? max\\'))\\n        self.freq_cw = scpiDevice(\\':FREQuency\\', str_type=float, min=minfreq, max=maxfreq)\\n        self.freq_center = scpiDevice(\\'FREQuency:CENTer\\', str_type=float, min=minfreq, max=maxfreq)\\n        self.freq_start = scpiDevice(\\'FREQuency:STARt\\', str_type=float, min=minfreq, max=maxfreq)\\n        self.freq_stop = scpiDevice(\\'FREQuency:STOP\\', str_type=float, min=minfreq, max=maxfreq)\\n        # TODO SPAN range is probably something else\\n        self.freq_span = scpiDevice(\\'FREQuency:SPAN\\', str_type=float, min=0, max=maxfreq)\\n        self.freq_multiplier = scpiDevice(\\':FREQuency:MULTiplier\\', str_type=float, min=-1000, max=1000, doc=\\'The range is -1000 to -0.001 and 0.001 to 1000\\')\\n        self.freq_offset = scpiDevice(\\':FREQuency:OFFSet\\', str_type=float, min=-200e9, max=200e9)\\n        self.freq_offset_en = scpiDevice(\\':FREQuency:OFFSet:STATe\\', str_type=bool)\\n        self.freq_reference = scpiDevice(\\':FREQuency:REFerence\\', str_type=float, min=0, max=maxfreq)\\n        self.freq_reference_en = scpiDevice(\\':FREQuency:REFerence:STATe\\', str_type=bool)\\n        self.phase = scpiDevice(\\':PHASe\\', str_type=float, min=-3.14, max=3.14, doc=\\'Adjust phase arounf ref. In rad.\\')\\n        # TODO handle the marker stuff\\n        self.mod_en = scpiDevice(\\':OUTPut:MODulation:STATe\\', str_type=bool)\\n        self.mod_am_en = scpiDevice(\\':AM:STATe\\', str_type=bool)\\n        self.mod_am_freq = scpiDevice(\\':AM:INTernal:FREQuency\\', str_type=float, min=0.5, max = 1e6, setget=True, doc=\"Frequency of the modulation. From 0 to 1MHz if mod_am_shape is \\'sine\\'; 0 to 100KHz else.\")\\n        self.mod_am_depth = scpiDevice(\\':AM:DEPTh:LINear\\', str_type=float, min=0, max = 100, setget=True, doc=\\'Modulation depth in percent\\')\\n        self.mod_am_shape = scpiDevice(\\':AM:INTernal:FUNCtion:SHAPe\\', choices=ChoiceStrings(\\'SINE\\', \\'SQUare\\', \\'TRIangle\\', \\'NOISe\\'), doc=\"Shape of the modulation\")\\n        self.mod_am_noise_type = scpiDevice(\\':AM:INTernal:FUNCtion:NOISE\\', choices=ChoiceStrings(\\'GAUSsian\\',\\'UNIForm\\'), doc=\"The noise profile used if mod_am_shape is set to \\'noise\\'\")\\n        self.mod_fm_en = scpiDevice(\\':FM:STATe\\', str_type=bool)\\n        self.mod_phase_en = scpiDevice(\\':PM:STATe\\', str_type=bool)\\n        self.mod_pulse_en = scpiDevice(\\':PULM:STATe\\', str_type=bool)\\n        self.mod_pulse_period = scpiDevice(\\':PULM:INTernal:PERiod\\', str_type=float, min=10e-9, max = 42, setget=True, doc=\"Pulse period in s.\")\\n        self.mod_pulse_width = scpiDevice(\\':PULM:INTernal:PWIDth\\', str_type=float, min=10e-9, max = 42-20e-9, setget=True, doc=\"Pulse width duration in s.\")\\n        self.alias = self.freq_cw\\n        # This needs to be last to complete creation\\n        super(agilent_rf_PSG,self)._create_devs()\\n    def phase_sync(self):\\n        \"\"\"\\n        Sets the current output phase as a zero reference.\\n        \"\"\"\\n        self.write(\\'PHASe:REFerence\\')\\n\\n\\n#######################################################\\n##    Agilent MXG generator\\n#######################################################\\n\\n#@register_instrument(\\'Agilent Technologies\\', \\'N5183A\\', \\'A.01.70\\')\\n@register_instrument(\\'Agilent Technologies\\', \\'N5183A\\', usb_vendor_product=[0x0957, 0x1F01], alias=\\'N5183A MXG Generator\\')\\nclass agilent_rf_MXG(agilent_rf_PSG):\\n    \"\"\"\\n    This controls a MXG signal generetor\\n    Most useful devices:\\n        ampl\\n        ampl_unit\\n        rf_en\\n        mod_en\\n        freq_cw\\n    The alc devices refer to automatic level (amplitude) control.\\n    Available methods:\\n        phase_sync\\n    \"\"\"\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        # TODO Get the proper config\\n        return self._conf_helper(\\'oscillator_source\\', \\'rf_en\\', \\'ampl\\', \\'ampl_unit\\', \\'amp_flatness_corr_en\\',\\n                                 \\'ampl_offset_db\\', \\'ampl_reference_dbm\\', \\'ampl_reference_en\\', \\'ampl_min_lim\\',\\n                                 \\'ampl_protection\\', \\'ampl_mode\\', \\'ampl_start\\', \\'ampl_stop\\', \\'ampl_user_max\\', \\'ampl_user_max_en\\',\\n                                 \\'alc_en\\', \\'alc_source\\', \\'alc_bw\\', \\'alc_bw_auto_en\\',\\n                                 \\'attenuation_db\\', \\'attenuation_auto_en\\', \\'amp_flatness_corr_en\\',\\n                                 \\'output_blanking_en\\', \\'output_blanking_auto_en\\',\\n                                 \\'freq_mode\\', \\'freq_cw\\', \\'freq_low_spurs_en\\', \\'freq_start\\', \\'freq_stop\\',\\n                                 \\'freq_multiplier\\', \\'freq_offset\\', \\'freq_offset_en\\', \\'freq_reference\\', \\'freq_reference_en\\',\\n                                 \\'phase\\', \\'mod_en\\', \\'mod_am_en\\', \\'mod_fm_en\\', \\'mod_phase_en\\', \\'mod_pulse_en\\', options)\\n    def _create_devs(self):\\n        self.ampl_min_lim = scpiDevice(\\':POWer:MINimum:LIMit\\', choices=ChoiceStrings(\\'LOW\\', \\'HIGH\\'))\\n        self.ampl_user_max = scpiDevice(\\':POWer:USER:MAX\\', str_type=float, doc=\\'unit depends on device ampl_unit\\', setget=True)\\n        self.ampl_user_max_en = scpiDevice(\\':POWer:USER:ENABle\\', str_type=bool)\\n        self.freq_low_spurs_en = scpiDevice(\\':FREQuency:LSPurs:STATe\\', str_type=bool)\\n        # This needs to be last to complete creation\\n        super(type(self),self)._create_devs()\\n    def phase_sync(self):\\n        \"\"\"\\n        Sets the current output phase as a zero reference.\\n        \"\"\"\\n        self.write(\\'PHASe:REFerence\\')\\n\\n\\n#######################################################\\n##    Agilent multimeter\\n#######################################################\\n\\n#@register_instrument(\\'Agilent Technologies\\', \\'34410A\\', \\'2.35-2.35-0.09-46-09\\')\\n@register_instrument(\\'Agilent Technologies\\', \\'34410A\\', usb_vendor_product=[0x0957, 0x0607], alias=\\'34410A multimeter\\')\\nclass agilent_multi_34410A(visaInstrumentAsync):\\n    \"\"\"\\n    This controls the agilent digital multimeters.\\n    Note that most of the devices requires a proper selection of the\\n    mode first. They can behave differently in various mode.\\n\\n    Important devices:\\n     readval  (default alias), same as initiating a measurement, waiting then fetch\\n     fetch\\n     fetch_all   (returns more than one value when count >1)\\n     fetch_std   (returns the standard deviation when count >1)\\n     mode\\n     aperture\\n     aperture_en\\n     nplc\\n     sample_count\\n     range\\n     autorange\\n     zero\\n    Useful method:\\n     set_long_avg  To average for even longer than 1s (controls aperture and sample_count)\\n     show_long_avg To see the current averaging settings.\\n\\n    Do NOT use the mode parameter of devices (like fetch) when creating\\n    files (sweep, trace, ...) because the headers in the file might be incorrect.\\n    Set it first.\\n\\n    \"\"\"\\n    def math_clear(self):\\n        self.write(\\'CALCulate:AVERage:CLEar\\')\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        mode = self.mode.getcache()\\n        choices = self.mode.choices\\n        baselist =(\\'mode\\', \\'trig_src\\', \\'trig_delay\\', \\'trig_count\\',\\n                   \\'sample_count\\', \\'sample_src\\', \\'sample_timer\\', \\'trig_delayauto\\',\\n                   \\'line_freq\\', \\'math_func\\')\\n        if mode in choices[[\\'curr:ac\\', \\'volt:ac\\']]:\\n            extra = (\\'bandwidth\\', \\'autorange\\', \\'range\\',\\n                     \\'null_en\\', \\'null_val\\', \\'peak_mode_en\\')\\n        elif mode in choices[[\\'volt\\', \\'curr\\']]:\\n            extra = (\\'nplc\\', \\'aperture\\', \\'aperture_en\\', \\'zero\\', \\'autorange\\', \\'range\\',\\n                     \\'null_en\\', \\'null_val\\', \\'peak_mode_en\\')\\n            if mode in choices[[\\'volt\\']]:\\n                extra += (\\'voltdc_impedance_autoHigh\\',)\\n        elif mode in choices[[\\'cont\\', \\'diode\\']]:\\n            extra = ()\\n        elif mode in choices[[\\'freq\\', \\'period\\']]:\\n            extra = (\\'aperture\\',\\'null_en\\', \\'null_val\\',  \\'freq_period_p_band\\',\\n                        \\'freq_period_autorange\\', \\'freq_period_volt_range\\')\\n        elif mode in choices[[\\'res\\', \\'fres\\']]:\\n            extra = (\\'nplc\\', \\'aperture\\', \\'aperture_en\\', \\'autorange\\', \\'range\\',\\n                     \\'null_en\\', \\'null_val\\', \\'res_offset_comp\\')\\n            if mode in choices[[\\'res\\']]:\\n                extra += (\\'zero\\',)\\n        elif mode in choices[[\\'cap\\']]:\\n            extra = (\\'autorange\\', \\'range\\', \\'null_en\\', \\'null_val\\')\\n        elif mode in choices[[\\'temp\\']]:\\n            extra = (\\'nplc\\', \\'aperture\\', \\'aperture_en\\', \\'null_en\\', \\'null_val\\',\\n                     \\'zero\\', \\'temperature_transducer\\', \\'temperature_transducer_subtype\\')\\n            t_ch = self.temperature_transducer.choices\\n            if self.temperature_transducer.getcache() in t_ch[[\\'rtd\\', \\'frtd\\']]:\\n                extra += (\\'temperature_transducer_rtd_ref\\', \\'temperature_transducer_rtd_off\\')\\n        return self._conf_helper(*(baselist + extra + (options,)))\\n    @locked_calling\\n    def set_long_avg(self, time, force=False):\\n        \"\"\"\\n        Select a time in seconds.\\n        It will change the aperture accordingly (and round it to the nearest nplc\\n        unless force=True).\\n        If time is greater than 1 s, an alternative mode\\n        with a smaller aperture (10 nplc) and a repeat count is used. That\\n        mode also waits trig_delay between each count.\\n        In that mode, you can use fetch_std to return the statistical error\\n        on the measurement.\\n        \"\"\"\\n        # update mode first, so aperture applies to correctly\\n        self.mode.get()\\n        line_period = 1./self.line_freq.getcache()\\n        if time > 1.:\\n            width = 10*line_period\\n            count = round(time/width)\\n            self.sample_src.set(\\'immediate\\')\\n        else:\\n            count = 1\\n            width = time\\n            if not force:\\n                width = line_period*round(width/line_period)\\n        self.aperture.set(width)\\n        self.sample_count.set(count)\\n    @locked_calling\\n    def show_long_avg(self):\\n        # update mode first, so aperture applies to correctly\\n        self.mode.get()\\n        count = self.sample_count.get()\\n        aper_en = self.aperture_en.get()\\n        if aper_en:\\n            width = self.aperture.get()\\n            width_str = \\'aperture=%g\\'%width\\n        else:\\n            line_period = 1./self.line_freq.getcache()\\n            nplc = self.nplc.get()\\n            width = nplc * line_period\\n            width_str = \\'nplc=%g\\'%nplc\\n        count_str = \\'\\'\\n        if count > 1:\\n            count_str = \\', sample_count=%i\\'%count\\n        width = width*count\\n        print \\'The full avg time is %f s (%s%s)\\'%(width, width_str, count_str)\\n        return width\\n    def _create_devs(self):\\n        # This needs to be last to complete creation\\n        ch = ChoiceStrings(\\n          \\'CURRent:AC\\', \\'VOLTage:AC\\', \\'CAPacitance\\', \\'CONTinuity\\', \\'CURRent\\', \\'VOLTage\\',\\n          \\'DIODe\\', \\'FREQuency\\', \\'PERiod\\', \\'RESistance\\', \\'FRESistance\\', \\'TEMPerature\\', quotes=True)\\n        self.mode = scpiDevice(\\'FUNC\\', choices=ch)\\n        def devOption(lims, *arg, **kwarg):\\n            options = kwarg.pop(\\'options\\', {}).copy()\\n            options_lim = kwarg.pop(\\'options_lim\\', {}).copy()\\n            options_conv = kwarg.pop(\\'options_conv\\', {}).copy()\\n            options.update(mode=self.mode)\\n            options_lim.update(mode=lims)\\n            options_conv.update(mode=lambda val, quoted_val: val)\\n            kwarg.update(options=options)\\n            kwarg.update(options_lim=options_lim)\\n            kwarg.update(options_conv=options_conv)\\n            return scpiDevice(*arg, **kwarg)\\n        # _decode_float64_avg is needed because count points are returned\\n        # fetch? and read? return sample_count*trig_count data values (comma sep)\\n        self.fetch = scpiDevice(getstr=\\'FETCh?\\',str_type=decode_float64_avg, autoinit=False, trig=True) #You can\\'t ask for fetch after an aperture change. You need to read some data first.\\n        # autoinit false because it can take too long to readval\\n        #self.readval = scpiDevice(getstr=\\'READ?\\',str_type=_decode_float64_avg, autoinit=False, redir_async=self.fetch) # similar to INItiate followed by FETCh.\\n        self.fetch_all = scpiDevice(getstr=\\'FETCh?\\',str_type=decode_float64, autoinit=False, trig=True)\\n        self.fetch_std = scpiDevice(getstr=\\'FETCh?\\',str_type=decode_float64_meanstd, autoinit=False, trig=True, doc=\"\"\"\\n             Use this to obtain the standard deviation(using ddof=1) of the fetch.\\n             It is the standard deviation of the mean (it decreases when the averaging is longer).\\n             This will only return something usefull for long time averages where\\n             count is > 1. This is the case with set_long_avg(time) for time longer\\n             than 1s.\\n             (fetch_all needs to have more than one value)\\n        \"\"\")\\n        self.line_freq = scpiDevice(getstr=\\'SYSTem:LFRequency?\\', str_type=float) # see also SYST:LFR:ACTual?\\n        ch_aper = ch[[\\'volt\\', \\'curr\\', \\'res\\', \\'fres\\', \\'temp\\', \\'freq\\', \\'period\\']]\\n        ch_aper_nplc = ch[[\\'volt\\', \\'curr\\', \\'res\\', \\'fres\\', \\'temp\\']]\\n        aper_max = float(self.ask(\\'volt:aper? max\\'))\\n        aper_min = float(self.ask(\\'volt:aper? min\\'))\\n        # TODO handle freq, period where valid values are .001, .010, .1, 1 (between .001 and 1 can use setget)\\n        self.aperture = devOption(ch_aper, \\'{mode}:APERture\\', str_type=float, min = aper_min, max = aper_max, setget=True)\\n        self.aperture_en = devOption(ch_aper_nplc, \\'{mode}:APERture:ENabled\\', str_type=bool)\\n        self.nplc = devOption(ch_aper_nplc, \\'{mode}:NPLC\\', str_type=float,\\n                                   choices=[0.006, 0.02, 0.06, 0.2, 1, 2, 10, 100])\\n        ch_band = ch[[\\'curr:ac\\', \\'volt:ac\\']]\\n        self.bandwidth = devOption(ch_band, \\'{mode}:BANDwidth\\', str_type=float,\\n                                   choices=[3, 20, 200]) # in Hz\\n        ch_freqperi = ch[[\\'freq\\', \\'per\\']]\\n        self.freq_period_p_band = devOption(ch_freqperi, \\'{mode}:RANGe:LOWer\\', str_type=float,\\n                                   choices=[3, 20, 200]) # in Hz\\n        self.freq_period_autorange = devOption(ch_freqperi, \\'{mode}:VOLTage:RANGe:AUTO\\', str_type=bool) # Also use ONCE (immediate autorange, then off)\\n        self.freq_period_volt_range = devOption(ch_freqperi, \\'{mode}:VOLTage:RANGe\\', str_type=float,\\n                                                choices=[.1, 1., 10., 100., 1000.]) # Setting this disables auto range\\n\\n        ch_zero = ch[[\\'volt\\', \\'curr\\', \\'res\\', \\'temp\\']] # same as ch_aper_nplc wihtout fres\\n        self.zero = devOption(ch_zero, \\'{mode}:ZERO:AUTO\\', str_type=bool,\\n                              doc=\\'Enabling auto zero double the time to take each point (the value and a zero correction is done for each point)\\') # Also use ONCE (immediate zero, then off)\\n        ch_range = ch[[0, 1, 2,  4, 5,  9, 10]] # everything except continuity, diode, freq, per and temperature\\n        self.autorange = devOption(ch_range, \\'{mode}:RANGE:AUTO\\', str_type=bool) # Also use ONCE (immediate autorange, then off)\\n        range_ch = ChoiceDevDep(self.mode, {ch[[\\'volt\\', \\'volt:ac\\']]:[.1, 1., 10., 100., 1000.],\\n                                            ch[[\\'curr\\', \\'curr:ac\\']]:[.1e-3, 1e-3, 1e-2, 1e-1, 1, 3],\\n                                            ch[[\\'fres\\', \\'res\\']]:[1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9] }) # in V, A, Ohm\\n        self.range = devOption(ch_range, \\'{mode}:RANGe\\', str_type=float, choices=range_ch) # Setting this disables auto range\\n        ch_null = ch[[0, 1, 2,  4, 5,  7, 8, 9, 10, 11]] # everything except continuity and diode\\n        self.null_en = devOption(ch_null, \\'{mode}:NULL\\', str_type=bool)\\n        self.null_val = devOption(ch_null, \\'{mode}:NULL:VALue\\', str_type=float)\\n        self.voltdc_impedance_autoHigh = scpiDevice(\\'VOLTage:IMPedance:AUTO\\', str_type=bool, doc=\\'When True and V range <= 10V then impedance >10 GO else it is 10 MOhm\\')\\n        tch = ChoiceStrings(\\'FRTD\\', \\'RTD\\', \\'FTHermistor\\', \\'THERmistor\\')\\n        self.temperature_transducer = scpiDevice(\\'TEMPerature:TRANsducer:TYPE\\', choices=tch)\\n        tch_rtd = tch[[\\'frtd\\', \\'rtd\\']]\\n        ch_temp_typ = ChoiceDevDep(self.temperature_transducer, {tch_rtd:[85], None:[2252, 5000, 10000]})\\n        self.temperature_transducer_subtype = scpiDevice(\\'TEMPerature:TRANsducer:{trans}:TYPE\\',\\n                                        choices = ch_temp_typ,\\n                                        options=dict(trans=self.temperature_transducer),\\n                                        str_type=int)\\n        self.temperature_transducer_rtd_ref = scpiDevice(\\'TEMPerature:TRANsducer:{trans}:RESistance\\',\\n                                        min = 49, max= 2.1e3, str_type=float,\\n                                        options=dict(trans=self.temperature_transducer),\\n                                        options_lim=dict(trans=tch_rtd))\\n        self.temperature_transducer_rtd_off = scpiDevice(\\'TEMPerature:TRANsducer:{trans}:OCOMpensated\\', str_type=bool,\\n                                        options=dict(trans=self.temperature_transducer),\\n                                        options_lim=dict(trans=tch_rtd))\\n\\n        ch_compens = ch[[\\'res\\', \\'fres\\']]\\n        self.res_offset_comp = devOption(ch_compens, \\'{mode}:OCOMpensated\\', str_type=bool)\\n        ch_peak = ch[[\\'volt\\', \\'volt:ac\\', \\'curr\\', \\'curr:ac\\']]\\n        self.peak_mode_en = devOption(ch_peak, \\'{mode}:PEAK:STATe\\', str_type=bool)\\n        peak_op = dict(peak=self.peak_mode_en)\\n        peak_op_lim = dict(peak=[True])\\n        self.fetch_peaks_ptp = devOption(ch_peak, \\'FETCh:{mode}:PTPeak\\', str_type=float,\\n                                         doc=\\'Call this after a fetch or readval\\',\\n                                         options=peak_op, options_lim=peak_op_lim, autoinit=False, trig=True)\\n        ch_peak_minmax = ch[[\\'volt\\', \\'curr\\']]\\n        self.fetch_peaks_min = devOption(ch_peak_minmax, \\'FETCh:{mode}:PEAK:MINimum\\', str_type=float,\\n                                         doc=\\'Call this after a fetch or readval\\',\\n                                         options=peak_op, options_lim=peak_op_lim, autoinit=False, trig=True)\\n        self.fetch_peaks_max = devOption(ch_peak_minmax, \\'FETCh:{mode}:PEAK:MAXimum\\', str_type=float,\\n                                         doc=\\'Call this after a fetch or readval\\',\\n                                         options=peak_op, options_lim=peak_op_lim, autoinit=False, trig=True)\\n        ch = ChoiceStrings(\\'NULL\\', \\'DB\\', \\'DBM\\', \\'AVERage\\', \\'LIMit\\')\\n        self.math_func = scpiDevice(\\'CALCulate:FUNCtion\\', choices=ch)\\n        self.math_state = scpiDevice(\\'CALCulate:STATe\\', str_type=bool)\\n        self.math_avg = scpiDevice(getstr=\\'CALCulate:AVERage:AVERage?\\', str_type=float, trig=True)\\n        self.math_count = scpiDevice(getstr=\\'CALCulate:AVERage:COUNt?\\', str_type=float, trig=True)\\n        self.math_max = scpiDevice(getstr=\\'CALCulate:AVERage:MAXimum?\\', str_type=float, trig=True)\\n        self.math_min = scpiDevice(getstr=\\'CALCulate:AVERage:MINimum?\\', str_type=float, trig=True)\\n        self.math_ptp = scpiDevice(getstr=\\'CALCulate:AVERage:PTPeak?\\', str_type=float, trig=True)\\n        self.math_sdev = scpiDevice(getstr=\\'CALCulate:AVERage:SDEViation?\\', str_type=float, trig=True)\\n        ch = ChoiceStrings(\\'IMMediate\\', \\'BUS\\', \\'EXTernal\\')\\n        self.trig_src = scpiDevice(\\'TRIGger:SOURce\\', choices=ch)\\n        self.trig_delay = scpiDevice(\\'TRIGger:DELay\\', str_type=float) # seconds\\n        self.trig_count = scpiDevice(\\'TRIGger:COUNt\\', str_type=float)\\n        self.sample_count = scpiDevice(\\'SAMPle:COUNt\\', str_type=int)\\n        ch = ChoiceStrings(\\'IMMediate\\', \\'TIMer\\')\\n        self.sample_src = scpiDevice(\\'SAMPle:SOURce\\', choices=ch)\\n        self.sample_timer = scpiDevice(\\'SAMPle:TIMer\\', str_type=float) # seconds\\n        self.trig_delayauto = scpiDevice(\\'TRIGger:DELay:AUTO\\', str_type=bool)\\n        self.readval = ReadvalDev(self.fetch)\\n        self.alias = self.readval\\n        super(type(self),self)._create_devs()\\n        # For INITiate: need to wait for completion of triggered measurement before calling it again\\n        # for trigger: *trg and visa.trigger seem to do the same. Can only be called after INItiate and\\n        #   during measurement.\\n        # To get completion stats: write(\\'INITiate;*OPC\\') and check results from *esr? bit 0\\n        #   enable with *ese 1 then check *stb bit 5 (32) (and clear *ese?)\\n        # Could also ask for data and look at bit 4 (16) output buffer ready\\n        #dmm1.mathfunc.set(\\'average\\');dmm1.math_state.set(True)\\n        #dmm1.write(\\'*ese 1;*sre 32\\')\\n        #dmm1.write(\\'init;*opc\\')\\n        #dmm1.read_status_byte()\\n        #dmm1.ask(\\'*stb?;*esr?\\')\\n        #dmm1.math_count.get(); dmm1.math_avg.get() # no need to reset count, init does that\\n        #visa.vpp43.enable_event(dmm1.visa.vi, visa.vpp43.VI_EVENT_SERVICE_REQ, visa.vpp43.VI_QUEUE)\\n        #dmm1.write(\\'init;*opc\\')\\n        #dmm1.read_status_byte()\\n        #visa.vpp43.wait_on_event(dmm1.visa.vi, visa.vpp43.VI_EVENT_SERVICE_REQ, 10000)\\n        #dmm1.read_status_byte()\\n        #dmm1.ask(\\'*stb?;*esr?\\')\\n        #  For installing handler (only seems to work with USB not GPIB for NI visa library. Seems to work fine with Agilent IO visa)\\n        #   def event_handler(vi, event_type, context, use_handle): stb = visa.vpp43.read_stb(vi);  print \\'helo 0x%x\\'%stb, event_type==visa.vpp43.VI_EVENT_SERVICE_REQ, context, use_handle; return visa.vpp43.VI_SUCCESS\\n        #   def event_handler(vi, event_type, context, use_handle): stb = visa.vpp43.read_stb(vi);  print \\'HELLO 0x%x\\'%stb,vi; return visa.vpp43.VI_SUCCESS\\n        #   visa.vpp43.install_handler(dmm1.visa.vi, visa.vpp43.VI_EVENT_SERVICE_REQ, event_handler)\\n        #   visa.vpp43.enable_event(dmm1.visa.vi, visa.vpp43.VI_EVENT_SERVICE_REQ, visa.vpp43.VI_HNDLR)\\n        #   The handler is called for all srq on the bus (not necessarily the instrument we want)\\n        #     the vi parameter refers to the installed handler, not the actual srq source\\n        #The wait_on_event seems to be handling only event from src, not affecting the other instruments srq\\n        # reading the status is not necessary after wait to clear srq (cleared during wait internal handler) for agilent visa\\n        #  but it is necessary for NI visa (it will receive the SRQ like for agilent but will not transmit\\n        #      the next ones to the wait queue until acknowledged)\\n        #      there seems to be some inteligent buffering going on, which is different in agilent and NI visas\\n        # When wait_on_event timesout, it produces the VisaIOError (VI_ERROR_TMO) exception\\n        #        the error code is available as VisaIOErrorInstance.error_code\\n\\n\\n#######################################################\\n##    Agilent RF attenuator\\n#######################################################\\n\\nregister_idn_alias(\\'Agilent Technologies\\', \\'AGILENT TECHNOLOGIES\\')\\n\\n#@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'J7211C\\', \\'A.00.04\\')\\n@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'J7211C\\', usb_vendor_product=[0x0957, 0x4C18], alias=\\'J7211C RF attenuator\\')\\nclass agilent_rf_Attenuator(visaInstrument):\\n    \"\"\"\\n    This controls an Agilent Attenuation Control Unit\\n    Use att_level_dB to get or change the attenuation level.\\n    Use cal_att_level_dB to obtain the calibrated attenuation.\\n    Note that the attenuation for 0dB is not included for the\\n    other calibration levels.\\n    \"\"\"\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        return self._conf_helper(\\'att_level_dB\\', \\'cal_att_level_dB\\', \\'current_freq_Hz\\',\\n                                 \\'relative_en\\', \\'relative_ref_dB\\', options)\\n    def _att_level_dB_getdev(self):\\n        return int(self.ask(\\'ATTenuation?\\'))\\n    def _att_level_dB_setdev(self, val):\\n        val = int(val)\\n        self.write(\\'ATTenuation %i\\'%val)\\n        sleep(0.02)\\n    def _create_devs(self):\\n        self.relative_en = scpiDevice(\\'RELative\\', str_type=bool)\\n        self.relative_ref_dB = scpiDevice(\\'REFerence\\', str_type=float)\\n        # TODO implement RELative:LEVel  (only when relative is enabled)\\n        self.current_freq_Hz = MemoryDevice(1e9, min=0, max=26.5e9)\\n        self._devwrap(\\'att_level_dB\\', min=0, max=101)\\n        #self.att_level_dB = scpiDevice(\\'ATTenuation\\', str_type=int, min=0, max=101)\\n        self.alias = self.att_level_dB\\n        self.cal_att_level_dB = scpiDevice(getstr=\\'CORRection? {att},{freq}\\', str_type=float,\\n                                           options=dict(att=self.att_level_dB, freq=self.current_freq_Hz),\\n                                           options_apply=[\\'freq\\'])\\n        # This needs to be last to complete creation\\n        super(agilent_rf_Attenuator, self)._create_devs()\\n\\n\\n#######################################################\\n##    Agilent infiniiVision Scopes\\n#######################################################\\n\\n#@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'DSO-X 2024A\\', \\'01.10.2011031600\\', usb_vendor_product=[0x0957, 0x1796])\\n#@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'DSO-X 3054A\\', \\'01.10.2011031600\\', usb_vendor_product=[0x0957, 0x17a2])\\n@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'DSO-X 2024A\\', usb_vendor_product=[0x0957, 0x1796])\\n@register_instrument(\\'AGILENT TECHNOLOGIES\\', \\'DSO-X 3054A\\', usb_vendor_product=[0x0957, 0x17a2])\\nclass infiniiVision_3000(visaInstrumentAsync):\\n    \"\"\"\\n     To use this instrument, the most useful devices are probably:\\n       fetch  (only works in the main timebase mode, not for roll or XY or zoom)\\n       readval (press run/stop on scope to terminate it, or use clear_dev method)\\n       snap_png\\n     See also the setup_trig_detection method.\\n     Be warned that fetch, resets the current acquistion and waits for the next\\n     when the scope is running (a firmware bug?).\\n     fetch when stopped is ok.\\n     Another way is to start an acq with single_trig, check the acq with is_running\\n     and then fetch it.\\n    \"\"\"\\n    def __init__(self, visa_addr, poll=\\'force_handler\\'):\\n        super(infiniiVision_3000, self).__init__(visa_addr, poll)\\n    def init(self, full=False):\\n        self.write(\\':WAVeform:FORMat WORD\\') # can be WORD BYTE or ASCii\\n        self.write(\\':WAVeform:BYTeorder LSBFirst\\') # can be LSBFirst pr MSBFirst\\n        self.write(\\':WAVeform:UNSigned ON\\') # ON,1 or OFF,0\\n        super(infiniiVision_3000, self).init(full=full)\\n    def _async_trigger_helper(self):\\n        self.digitize()\\n        self.write(\\'*OPC\\')\\n        #self.write(\\':DIGitize;*OPC\\')\\n    @locked_calling\\n    def _current_config(self, dev_obj=None, options={}):\\n        # TODO:  improve this\\n        return self._conf_helper(\\'source\\', \\'points_mode\\', \\'preamble\\', options)\\n    def clear_dev(self):\\n        self.visa.instr.clear()\\n    def setup_trig_detection(self):\\n        \"\"\" This setups trig detection. Only use this on one thread and not with readval (run_and_wait).\\n            Undo its effect with reset_trig_detection.\\n            After calling this use:\\n              s.single_trig()\\n              get(s.trig_status) # when True there was a trig event\\n              get(s.lasttrig_time) # if not 0. then there it is the last trig time\\n            The trig time accuracy is probably within 100 ms.\\n        \"\"\"\\n        # lets presume we were started with poll=\\'force_handler\\'\\n        self.write(\\'*sre 1\\')\\n        self.visa.enable_event(visa_wrap.constants.VI_EVENT_SERVICE_REQ,\\n                               visa_wrap.constants.VI_HNDLR)\\n    def reset_trig_detection(self):\\n        self.visa.disable_event(visa_wrap.constants.VI_EVENT_SERVICE_REQ, visa_wrap.constants.VI_ALL_MECH)\\n        self.write(\\'*sre 32\\')\\n    def digitize(self):\\n        \"\"\"\\n        Starts an acquisition\\n        \"\"\"\\n        self.write(\\':DIGitize\\')\\n    def run_trig(self):\\n        \"\"\"\\n        The same as pressing run\\n        \"\"\"\\n        self.write(\\':RUN\\')\\n    def stop_trig(self):\\n        \"\"\"\\n        The same as pressing stop\\n        \"\"\"\\n        self.write(\\':STOP\\')\\n    def single_trig(self):\\n        \"\"\"\\n        The same as pressing single\\n        \"\"\"\\n        self.trig_status.get() # reset trig\\n        self._async_last_status_time = 0.\\n        self.write(\\':SINGle\\')\\n    def is_running(self):\\n        status = int(self.ask(\\'OPERegister:condition?\\'))\\n        # OPERregister[:event]? is a latch of 0-> from OPERegister:condition?\\n        # it goes through OPEE (mask) to affect OPER bit7 (128) of *STB\\n        # OPER has bits 11(Overload), 9(masks), 5(arm, see AER?), 3(run state)\\n        run_state = 8 # 2**3\\n        return bool(status&run_state)\\n    def _lasttrig_time_getdev(self):\\n        return self._async_last_status_time\\n    def _fetch_ch_helper(self, ch):\\n        if ch is None:\\n            ch = self.find_all_active_channels()\\n        if not isinstance(ch, (list)):\\n            ch = [ch]\\n        return ch\\n    def _fetch_getformat(self, **kwarg):\\n        xaxis = kwarg.get(\\'xaxis\\', True)\\n        ch = kwarg.get(\\'ch\\', None)\\n        ch = self._fetch_ch_helper(ch)\\n        if xaxis:\\n            multi = [\\'time(s)\\']\\n        else:\\n            multi = []\\n        for c in ch:\\n            multi.append(\\'ch%i\\'%c)\\n        fmt = self.fetch._format\\n        multi = tuple(multi)\\n        fmt.update(multi=multi, graph=[], xaxis=xaxis)\\n        return BaseDevice.getformat(self.fetch, **kwarg)\\n    def _fetch_getdev(self, ch=None, xaxis=True):\\n        \"\"\"\\n           Options available: ch, xaxis\\n            -ch:    a single value or a list of values for the channels to capture\\n                    a value of None selects all the active ones.(1-4)\\n            -xaxis: Set to True (default) to return the timebase as the first column\\n        \"\"\"\\n        ch = self._fetch_ch_helper(ch)\\n        if ch is None:\\n            ch = self.find_all_active_channels()\\n        if not isinstance(ch, (list)):\\n            ch = [ch]\\n        ret = []\\n        first = True\\n        for c in ch:\\n            self.source.set(\\'chan%i\\'%c)\\n            pream = self.preamble.get()\\n            data = self.data.get()*1. # make it floats\\n            data_real = (data - pream[\\'yref\\']) * pream[\\'yinc\\'] + pream[\\'yorig\\']\\n            if xaxis and first:\\n                first = False\\n                ret = [(np.arange(pream[\\'points\\'])- pream[\\'xref\\']) * pream[\\'xinc\\'] + pream[\\'xorig\\']]\\n            ret.append(data_real)\\n        ret = np.asarray(ret)\\n        if ret.shape[0]==1:\\n            ret=ret[0]\\n        return ret\\n    @locked_calling\\n    def find_all_active_channels(self):\\n        orig_ch = self.current_channel.get()\\n        ret = []\\n        for i in range(1,5):\\n            if self.channel_display.get(ch=i):\\n                ret.append(i)\\n        self.current_channel.set(orig_ch)\\n        return ret\\n    def _create_devs(self):\\n        self.snap_png = scpiDevice(getstr=\\':DISPlay:DATA? PNG, COLor\\', raw=True, str_type=_decode_block_base, autoinit=False, doc=\"Use like this: get(s500.snap_png, filename=\\'testname.png\\')\\\\nThe .png extensions is optional. It will be added if necessary.\")\\n        self.snap_png._format[\\'bin\\']=\\'.png\\'\\n        self.inksaver = scpiDevice(\\':HARDcopy:INKSaver\\', str_type=bool, doc=\\'This control whether the graticule colors are inverted or not.\\') # ON, OFF 1 or 0\\n        self.data = scpiDevice(getstr=\\':waveform:DATA?\\', raw=True, str_type=decode_uint16_bin, autoinit=False) # returns block of data (always header# for asci byte and word)\\n          # also read :WAVeform:PREamble?, which provides, format(byte,word,ascii),\\n          #  type (Normal, peak, average, HRes), #points, #avg, xincr, xorg, xref, yincr, yorg, yref\\n          #  xconv = xorg+x*xincr, yconv= (y-yref)*yincr + yorg\\n        self.points = scpiDevice(\\':WAVeform:POINts\\', str_type=int) # 100, 250, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000, 200000, 500000, 1000000, 2000000, 4000000, 8000000\\n        self.points_mode = scpiDevice(\\':WAVeform:POINts:MODE\\', choices=ChoiceStrings(\\'NORMal\\', \\'MAXimum\\', \\'RAW\\'))\\n        self.preamble = scpiDevice(getstr=\\':waveform:PREamble?\\', choices=ChoiceMultiple([\\'format\\', \\'type\\', \\'points\\', \\'count\\', \\'xinc\\', \\'xorig\\', \\'xref\\', \\'yinc\\', \\'yorig\\', \\'yref\\'],[int, int, int, int, float, float, int, float, float, int]))\\n        self.waveform_count = scpiDevice(getstr=\\':WAVeform:COUNt?\\', str_type=int)\\n        self.acq_type = scpiDevice(\\':ACQuire:TYPE\\', choices=ChoiceStrings(\\'NORMal\\', \\'AVERage\\', \\'HRESolution\\', \\'PEAK\\'))\\n        self.acq_mode= scpiDevice(\\':ACQuire:MODE\\', choices=ChoiceStrings(\\'RTIM\\', \\'SEGM\\'))\\n        self.average_count = scpiDevice(\\':ACQuire:COUNt\\', str_type=int, min=2, max=65536)\\n        self.acq_samplerate = scpiDevice(getstr=\\':ACQuire:SRATe?\\', str_type=float)\\n        self.acq_npoints = scpiDevice(getstr=\\':ACQuire:POINts?\\', str_type=int)\\n        self.current_channel = MemoryDevice(1, min=1, max=4)\\n        self.trig_status = scpiDevice(getstr=\\':TER?\\', str_type=bool, autoinit=False, doc=\"This returns True after the instrument has been triggered. It also resets the trig state.\")\\n        def devChannelOption(*arg, **kwarg):\\n            options = kwarg.pop(\\'options\\', {}).copy()\\n            options.update(ch=self.current_channel)\\n            app = kwarg.pop(\\'options_apply\\', [\\'ch\\'])\\n            kwarg.update(options=options, options_apply=app)\\n            return scpiDevice(*arg, **kwarg)\\n        self.source = scpiDevice(\\':WAVeform:SOURce\\', choices=ChoiceStrings(\\'CHANnel1\\', \\'CHANnel2\\', \\'CHANnel3\\', \\'CHANnel4\\'))\\n        self.channel_display = devChannelOption(\\'CHANnel{ch}:DISPlay\\', str_type=bool)\\n        self.timebase_mode= scpiDevice(\\':TIMebase:MODE\\', choices=ChoiceStrings(\\'MAIN\\', \\'WINDow\\', \\'XY\\', \\'ROLL\\'))\\n        self.timebase_pos= scpiDevice(\\':TIMebase:POSition\\', str_type=float) # in seconds from trigger to display ref\\n        self.timebase_range= scpiDevice(\\':TIMebase:RANGe\\', str_type=float) # in seconds, full scale\\n        self.timebase_reference= scpi'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tiktoken\n",
    "\n",
    "enc = tiktoken.encoding_for_model(\"gpt-3.5-turbo\")\n",
    "e = enc.encode(code)\n",
    "\n",
    "enc.decode(e[:15000])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}