{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 3: Contributing to SQuADDS\n",
    "\n",
    "In this tutorial, we will go over the basics of contributing data to the SQuADDS project. We will cover the following topics:\n",
    "\n",
    "0. [Contribution Information Setup](#setup)\n",
    "1. [Understanding the terminology and database structure](#structure)\n",
    "2. [Contributing to an existing dataset configuration](#existing)\n",
    "3. [Creating new dataset configuration](#creation)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"setup\">Contribution Information Setup</a>\n",
    "\n",
    "In order to contribute to SQuADDS, you will need to provide some information about yourself. This information will be used to track your contributions and to give you credit for your work. You can provide this information by updating the following variables in the `.env` file in the root directory of the repository:\n",
    "\n",
    "```\n",
    "GROUP_NAME = \"\"\n",
    "PI_NAME = \"\"\n",
    "INSTITUTION = \"\"\n",
    "USER_NAME = \"\"\n",
    "CONTRIB_MISC = \"\"\n",
    "```\n",
    "\n",
    "where `GROUP_NAME` is the name of your research group, `PI_NAME` is the name of your PI, `INSTITUTION` is the name of your institution, `USER_NAME` is your name, and `CONTRIB_MISC` is any other information you would like to provide about your contributions (e.g. bibTex citation, paper link, etc).\n",
    "\n",
    "Alternatively, you can provide this information by executing the following cell.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from squadds.database.utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contributor information updated in .env file (c:\\Users\\PowerAdmin.WIN-NQ8Q8E6B720\\.conda\\envs\\qiskit_metal\\Lib\\site-packages/.env).\n"
     ]
    }
   ],
   "source": [
    "create_contributor_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also ensure the `HUGGINGFACE_API_KEY` is also set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from squadds.core.utils import set_huggingface_api_key\n",
    "\n",
    "set_huggingface_api_key()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Later in the tutorial, we introduce some functionalities that require a GitHub token. If you do not have a GitHub token, you can create one by following the instructions [here](https://docs.github.com/en/github/authenticating-to-github/creating-a-personal-access-token). Create the PAT (Personal Access Token) with **GitHub (with `repo` scopes) and save the token as `GITHUB_TOKEN` in the `.env` file located at the root of the project**. \n",
    "\n",
    "Alternatively, you can execute the following cell to set the `GITHUB_TOKEN`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from squadds.core.utils import set_github_token\n",
    "\n",
    "set_github_token()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last thing you would need to do is to add your public SSH key to your HuggingFace account ([https://huggingface.co/settings/keys](https://huggingface.co/settings/keys))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"structure\">Understanding the terminology and database structure</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"hugging_face\">HuggingFace</a>\n",
    "\n",
    "[HuggingFace](https://huggingface.co/) stands at the forefront of the AI revolution, offering a dynamic collaboration platform for the machine learning community. Renowned for hosting an array of open-source machine learning libraries and tools, Hugging Face Hub serves as a central repository where individuals can share, explore, and innovate with ML technologies. The platform is dedicated to fostering an environment of learning, collaboration, and ethical AI, bringing together a rapidly expanding community of ML engineers, scientists, and enthusiasts.\n",
    "\n",
    "In our pursuit to enhance the versatility and utility of SQuADDS for quantum hardware developers and machine learning researchers, we have chosen to host our database on the HuggingFace platform. This strategic decision leverages HuggingFace's capability to support and facilitate research with machine learning models, aligning with methodologies outlined in various references. By making the SQuADDS database readily accessible on this platform, we aim to contribute to the development of cutting-edge Electronic Design Automation (EDA) tools. Our goal is to replicate the transformative impact witnessed in the semiconductor industry, now in the realm of superconducting quantum hardware.\n",
    "\n",
    "Key to our choice of HuggingFace is its [datasets](https://huggingface.co/datasets) library, which provides a unified interface for accessing a wide range of datasets. This feature is integral to SQuADDS, offering a streamlined and cohesive interface to our database. The decentralized nature of HuggingFace datasets significantly enhances community-driven development and access, a functionality that can be challenging to implement with traditional data storage platforms. This aspect of HuggingFace aligns perfectly with our vision for SQuADDS, enabling us to foster a collaborative and open environment for innovation in quantum technology."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"datasets_config\">Datasets & Configurations</a>\n",
    "\n",
    "As seen in [Tutorial 1](https://lfl-lab.github.io/SQuADDS/source/tutorials/Tutorial-1_Getting_Started_with_SQuADDS.html#Accessing-the-SQuADDS-Database-using-the-HuggingFace-API) we have organized the SQuADDS database into datasets and configurations. Let's quickly review about these two concepts and how they are used in SQuADDS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each configuration in the dataset is uniquely identified by their `config`. For the SQuADDS Database, the `config` string is created in the following format:\n",
    "\n",
    "```python\n",
    "config = f\"{component}_{component_name}_{data_type}\"\n",
    "```\n",
    "\n",
    "where `component` is the name of the component, `component_name` is the name of the component (in Qiskit Metal), and `data_type` is the type of simulation data that has been contributed. \n",
    "\n",
    "This structured approach ensures that users can query specific parts of the dataset relevant to their work, such as a particular type of qubit design or simulation results. This API abstraction allows for more complex queries and operations on the data, facilitating a more efficient workflow for researchers and developers.\n",
    "\n",
    "Lets check what the `config` string looks like for our database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['qubit-TransmonCross-cap_matrix', 'cavity_claw-RouteMeander-eigenmode', 'coupler-NCap-cap_matrix']\n"
     ]
    }
   ],
   "source": [
    "from datasets import get_dataset_config_names\n",
    "\n",
    "configs = get_dataset_config_names(\"SQuADDS/SQuADDS_DB\")\n",
    "print(configs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now access the database using the `config` string. For example, if you want to access the `qubit-TransmonCross-cap_matrix` configuration, you can do so by executing the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7f86d1524384c9294e4575982170a6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6b5d6604af41463e9481a3d440545215",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f4bd671883324631a0ce390946834982",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DatasetDict({\n",
      "    train: Dataset({\n",
      "        features: ['design', 'sim_options', 'sim_results', 'notes', 'contributor'],\n",
      "        num_rows: 1934\n",
      "    })\n",
      "})\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "\n",
    "qubit_data = load_dataset(\"SQuADDS/SQuADDS_DB\", configs[0])\n",
    "print(qubit_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please review [Section \"Using the SQuADDS API to access and anlyze the database\" in Tutorial 1](https://lfl-lab.github.io/SQuADDS/source/tutorials/Tutorial-1_Getting_Started_with_SQuADDS.html#Accessing-the-SQuADDS-Database-using-the-HuggingFace-API) where we introduce and explain how to use the SQuADDS API to access and analyze the database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <a name=\"dataset_schema\">Database Schema</a>\n",
    "\n",
    "Each contributed entry to SQuADDS must **AT LEAST** have the following fields. One can add as many more supplementary fields as one wants.\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"design\":{\n",
    "        \"design_tool\": design_tool_name,\n",
    "        \"design_options\": design_options,\n",
    "    },\n",
    "    \"sim_options\":{\n",
    "        \"setup\": sim_setup_options,\n",
    "        \"simulator\": simulator_name,\n",
    "    },\n",
    "    \"sim_results\":{\n",
    "        \"result1\": sim_result1,\n",
    "        \"result1_unit\": unit1,\n",
    "        \"result2\": sim_result2,\n",
    "        \"result2_unit\": unit2,\n",
    "    },\n",
    "    \"contributor\":{\n",
    "        \"group\": group_name,\n",
    "        \"PI\": pi_name,\n",
    "        \"institution\": institution,\n",
    "        \"uploader\": user_name,\n",
    "        \"misc\": contrib_misc,\n",
    "        \"date_created\": \"YYYY-MM-DD-HHMMSS\",\n",
    "    },\n",
    "}\n",
    "```\n",
    "\n",
    "If all the `sim_results` has the same units you can just use a `\"units\":units` field instead of repeating the unit for each result. \n",
    "\n",
    "**Note:** The `\"contributor\"` field is automatically added by the SQuADDS API when you upload your dataset. You do not need to add this field yourself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets look at the schema for the `qubit-TransmonCross-cap_matrix` configuration that used `qiskit-metal` as the design tool and `Ansys HFSS` as the simulation engine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a98b52df08b94d1099f4f66f9416e3c9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.25k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from squadds import SQuADDS_DB\n",
    "\n",
    "db = SQuADDS_DB()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e63577f5f72f458b830d54b36f70b0ed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "82d8a7f63e83425ea93881403713beae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b29943413b394bc0b5f94374ab9ab20b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================================================================\n",
      "Dataset Features:\n",
      "{'contributor': {'PI': Value(dtype='string', id=None),\n",
      "                 'date_created': Value(dtype='string', id=None),\n",
      "                 'group': Value(dtype='string', id=None),\n",
      "                 'institution': Value(dtype='string', id=None),\n",
      "                 'uploader': Value(dtype='string', id=None)},\n",
      " 'design': {'design_options': {...},\n",
      "            'design_tool': Value(dtype='string', id=None)},\n",
      " 'notes': {},\n",
      " 'sim_options': {'renderer_options': {...},\n",
      "                 'setup': {...},\n",
      "                 'simulator': Value(dtype='string', id=None)},\n",
      " 'sim_results': {'claw_to_claw': Value(dtype='float64', id=None),\n",
      "                 'claw_to_ground': Value(dtype='float64', id=None),\n",
      "                 'cross_to_claw': Value(dtype='float64', id=None),\n",
      "                 'cross_to_cross': Value(dtype='float64', id=None),\n",
      "                 'cross_to_ground': Value(dtype='float64', id=None),\n",
      "                 'ground_to_ground': Value(dtype='float64', id=None),\n",
      "                 'units': Value(dtype='string', id=None)}}\n",
      "\n",
      "Dataset Description:\n",
      "\n",
      "\n",
      "Dataset Citation:\n",
      "\n",
      "\n",
      "Dataset Homepage:\n",
      "\n",
      "\n",
      "Dataset License:\n",
      "\n",
      "\n",
      "Dataset Size in Bytes:\n",
      "9735651\n",
      "================================================================================\n"
     ]
    }
   ],
   "source": [
    "db.get_dataset_info(component=\"qubit\", component_name=\"TransmonCross\", data_type=\"cap_matrix\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"existing\">Contributing to an existing configuration</a>\n",
    "\n",
    "### Single Entry Contribution:\n",
    "\n",
    "Let's revisit [Tutorial 2](https://lfl-lab.github.io/SQuADDS/source/tutorials/Tutorial-2_Simulate_interpolated_designs.html#Simulate-the-Target-Design) where we simulated a novel `TransmonCross` qubit design. We will now learn how to contribute this design to the SQuADDS database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have provided a simple API for contributing to the SQuADDS database. The high level steps for contributing to an existing configuration via the SQuADDS API are as follows:\n",
    "\n",
    "1. **Select the dataset configuration**: Select the dataset configuration you would like to contribute to. \n",
    "\n",
    "2. **Validate your data**: Validate your data against the dataset configuration.\n",
    "\n",
    "3. **Submit your data**: Submit your data to the SQuADDS database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the example from [Tutorial 2](https://lfl-lab.github.io/SQuADDS/source/tutorials/Tutorial-2_Simulate_interpolated_designs.html#Extracting-the-data-needed-for-contributing-to-the-dataset), we will now go through each of these steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from squadds.database.contributor import ExistingConfigData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca66c5a51535496991ae5be5b8d268c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.25k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = ExistingConfigData('qubit-TransmonCross-cap_matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "87d7cc8b0ff1483ab6d036a31a2aca54",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5813679d933240629abceb4859d8c8ab",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c5f5a71ae1cb4eb7b8fc5130fde8a655",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"design\": {\n",
      "    \"design_options\": \"dict\",\n",
      "    \"design_tool\": \"str\"\n",
      "  },\n",
      "  \"sim_options\": {\n",
      "    \"renderer_options\": \"dict\",\n",
      "    \"setup\": \"dict\",\n",
      "    \"simulator\": \"str\"\n",
      "  },\n",
      "  \"sim_results\": {\n",
      "    \"claw_to_claw\": \"float\",\n",
      "    \"claw_to_ground\": \"float\",\n",
      "    \"cross_to_claw\": \"float\",\n",
      "    \"cross_to_cross\": \"float\",\n",
      "    \"cross_to_ground\": \"float\",\n",
      "    \"ground_to_ground\": \"float\",\n",
      "    \"units\": \"str\"\n",
      "  },\n",
      "  \"notes\": {},\n",
      "  \"contributor\": \"dict\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "data.show_config_schema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "design_options = {'pos_x': '-1500um',\n",
    "  'pos_y': '1200um',\n",
    "  'orientation': '-90',\n",
    "  'chip': 'main',\n",
    "  'layer': '1',\n",
    "  'connection_pads': {'readout': {'connector_type': '0',\n",
    "    'claw_length': '190um',\n",
    "    'ground_spacing': '10um',\n",
    "    'claw_width': '15um',\n",
    "    'claw_gap': '5.1um',\n",
    "    'claw_cpw_length': '40um',\n",
    "    'claw_cpw_width': '10um',\n",
    "    'connector_location': '90'}},\n",
    "  'cross_width': '30um',\n",
    "  'cross_length': '310um',\n",
    "  'cross_gap': '30um',\n",
    "  'hfss_inductance': 9.686e-09,\n",
    "  'hfss_capacitance': 0,\n",
    "  'hfss_resistance': 0,\n",
    "  'hfss_mesh_kw_jj': 7e-06,\n",
    "  'q3d_inductance': '10nH',\n",
    "  'q3d_capacitance': 0,\n",
    "  'q3d_resistance': 0,\n",
    "  'q3d_mesh_kw_jj': 7e-06,\n",
    "  'gds_cell_name': 'my_other_junction',\n",
    "  'aedt_q3d_inductance': 1e-08,\n",
    "  'aedt_q3d_capacitance': 0,\n",
    "  'aedt_hfss_inductance': 9.686e-09,\n",
    "  'aedt_hfss_capacitance': 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f57b33f15fc044bdaa51dd6bdbf8e3d0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eab366afcbd24f9db1541420d43ce330",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "38d684b4c034488583ea30cd6c65b1d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.add_design({\"design_options\": design_options, \"design_tool\":\"qiskit_metal\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.add_sim_result(\"cross_to_ground\", 157.6063, \"fF\")\n",
    "data.add_sim_result(\"claw_to_ground\", 101.24431, \"fF\")\n",
    "data.add_sim_result(\"cross_to_claw\", 4.517, \"fF\")\n",
    "data.add_sim_result(\"cross_to_cross\", 164.52267, \"fF\")\n",
    "data.add_sim_result(\"claw_to_claw\", 106.18101, \"fF\")\n",
    "data.add_sim_result(\"ground_to_ground\", 320.80404, \"fF\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we had the data from the simulation stored in the `examples/single_xmon_lom.json` we can just read the required fields from it for convience, then add the simulation setup & note it down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "# read file\n",
    "results_file = json.load(open(\"examples/single_xmon_lom.json\", \"r\"))\n",
    "sim_options = results_file[\"sim_options\"]\n",
    "setup = sim_options[\"setup\"]\n",
    "renderer_options = sim_options[\"renderer_options\"]\n",
    "\n",
    "data.add_sim_setup({\n",
    "\"setup\": setup,\n",
    "\"simulator\": \"ANSYS HFSS\",\n",
    "\"renderer_options\": renderer_options\n",
    "})\n",
    "\n",
    "data.add_notes({\"message\":\"this is a test entry\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what the entry that we have built so far looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"design\": {\n",
      "        \"design_tool\": \"qiskit_metal\",\n",
      "        \"design_options\": {\n",
      "            \"pos_x\": \"-1500um\",\n",
      "            \"pos_y\": \"1200um\",\n",
      "            \"orientation\": \"-90\",\n",
      "            \"chip\": \"main\",\n",
      "            \"layer\": \"1\",\n",
      "            \"connection_pads\": {\n",
      "                \"readout\": {\n",
      "                    \"connector_type\": \"0\",\n",
      "                    \"claw_length\": \"190um\",\n",
      "                    \"ground_spacing\": \"10um\",\n",
      "                    \"claw_width\": \"15um\",\n",
      "                    \"claw_gap\": \"5.1um\",\n",
      "                    \"claw_cpw_length\": \"40um\",\n",
      "                    \"claw_cpw_width\": \"10um\",\n",
      "                    \"connector_location\": \"90\"\n",
      "                }\n",
      "            },\n",
      "            \"cross_width\": \"30um\",\n",
      "            \"cross_length\": \"310um\",\n",
      "            \"cross_gap\": \"30um\",\n",
      "            \"hfss_inductance\": 9.686e-09,\n",
      "            \"hfss_capacitance\": 0,\n",
      "            \"hfss_resistance\": 0,\n",
      "            \"hfss_mesh_kw_jj\": 7e-06,\n",
      "            \"q3d_inductance\": \"10nH\",\n",
      "            \"q3d_capacitance\": 0,\n",
      "            \"q3d_resistance\": 0,\n",
      "            \"q3d_mesh_kw_jj\": 7e-06,\n",
      "            \"gds_cell_name\": \"my_other_junction\",\n",
      "            \"aedt_q3d_inductance\": 1e-08,\n",
      "            \"aedt_q3d_capacitance\": 0,\n",
      "            \"aedt_hfss_inductance\": 9.686e-09,\n",
      "            \"aedt_hfss_capacitance\": 0\n",
      "        }\n",
      "    },\n",
      "    \"sim_options\": {\n",
      "        \"setup\": {\n",
      "            \"name\": \"sweep_setup\",\n",
      "            \"reuse_selected_design\": false,\n",
      "            \"reuse_setup\": false,\n",
      "            \"freq_ghz\": 5.0,\n",
      "            \"save_fields\": false,\n",
      "            \"enabled\": true,\n",
      "            \"max_passes\": 30,\n",
      "            \"min_passes\": 2,\n",
      "            \"min_converged_passes\": 1,\n",
      "            \"percent_error\": 0.1,\n",
      "            \"percent_refinement\": 30,\n",
      "            \"auto_increase_solution_order\": true,\n",
      "            \"solution_order\": \"High\",\n",
      "            \"solver_type\": \"Iterative\",\n",
      "            \"run\": {\n",
      "                \"name\": \"LOMv2.0\",\n",
      "                \"components\": [\n",
      "                    \"xmon\"\n",
      "                ],\n",
      "                \"open_terminations\": [\n",
      "                    [\n",
      "                        \"xmon\",\n",
      "                        \"readout\"\n",
      "                    ]\n",
      "                ],\n",
      "                \"box_plus_buffer\": true\n",
      "            }\n",
      "        },\n",
      "        \"simulator\": \"ANSYS HFSS\",\n",
      "        \"renderer_options\": {\n",
      "            \"Lj\": \"10nH\",\n",
      "            \"Cj\": 0,\n",
      "            \"_Rj\": 0,\n",
      "            \"max_mesh_length_jj\": \"7um\",\n",
      "            \"max_mesh_length_port\": \"7um\",\n",
      "            \"project_path\": null,\n",
      "            \"project_name\": null,\n",
      "            \"design_name\": null,\n",
      "            \"x_buffer_width_mm\": 0.2,\n",
      "            \"y_buffer_width_mm\": 0.2,\n",
      "            \"wb_threshold\": \"400um\",\n",
      "            \"wb_offset\": \"0um\",\n",
      "            \"wb_size\": 5,\n",
      "            \"plot_ansys_fields_options\": {\n",
      "                \"name\": \"NAME:Mag_E1\",\n",
      "                \"UserSpecifyName\": \"0\",\n",
      "                \"UserSpecifyFolder\": \"0\",\n",
      "                \"QuantityName\": \"Mag_E\",\n",
      "                \"PlotFolder\": \"E Field\",\n",
      "                \"StreamlinePlot\": \"False\",\n",
      "                \"AdjacentSidePlot\": \"False\",\n",
      "                \"FullModelPlot\": \"False\",\n",
      "                \"IntrinsicVar\": \"Phase='0deg'\",\n",
      "                \"PlotGeomInfo_0\": \"1\",\n",
      "                \"PlotGeomInfo_1\": \"Surface\",\n",
      "                \"PlotGeomInfo_2\": \"FacesList\",\n",
      "                \"PlotGeomInfo_3\": \"1\"\n",
      "            }\n",
      "        }\n",
      "    },\n",
      "    \"sim_results\": {\n",
      "        \"cross_to_ground\": 157.6063,\n",
      "        \"claw_to_ground\": 101.24431,\n",
      "        \"cross_to_claw\": 4.517,\n",
      "        \"cross_to_cross\": 164.52267,\n",
      "        \"claw_to_claw\": 106.18101,\n",
      "        \"ground_to_ground\": 320.80404,\n",
      "        \"units\": \"fF\"\n",
      "    },\n",
      "    \"contributor\": {\n",
      "        \"group\": \"Levenson-Falk Lab\",\n",
      "        \"PI\": \"Eli Levenson-Falk\",\n",
      "        \"institution\": \"USC\",\n",
      "        \"uploader\": \"Sadman Ahmed Shanto\",\n",
      "        \"misc\": \"https://arxiv.org/pdf/2312.13483.pdf\",\n",
      "        \"date_created\": \"2024-01-17 222441\"\n",
      "    },\n",
      "    \"notes\": {\n",
      "        \"message\": \"this is a test entry\"\n",
      "    }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "data.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks about correct by eye but lets ensure it is actually valid by executing the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "\n",
      "Missing keys found. These keys are present in one dictionary but not the other:\n",
      "\n",
      "Key: contributor.misc is missing in 'ref'\n",
      "Key: notes.message is missing in 'ref'\n"
     ]
    }
   ],
   "source": [
    "data.validate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems that there are no error messages - the missing keys are optional keys that we can add if we want but we can certainly move on without it. We are now ready to submit our data to the SQuADDS database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Uploading the data\n",
    "\n",
    "We can upload our validated entries via HuggingFace. The high level steps are as follows:\n",
    "\n",
    "   1. **Clone/Fork the Repository**: If you have not already forked or cloned the [repository](https://huggingface.co/datasets/SQuADDS/SQuADDS_DB), please do so.\n",
    "   2. **Create or Checkout a Branch**: If adding new data, it might be best to do it on a new branch:\n",
    "      ```\n",
    "      git checkout -b branch_name,\n",
    "      ```\n",
    "   3. **Modify the Configuration**: Append your validated data entries to your **selected dataset configuration**.\n",
    "\n",
    "   4. **Commit and Push Your Changes**: Commit the new data and push it to your fork:\n",
    "      ```\n",
    "      git add .\n",
    "      git commit -m \"GOOD COMMIT MESSAGE\"\n",
    "      git push origin branch_name\n",
    "      ```\n",
    "   5. **Pull Request**: Create a pull request against the original `SQuADDS_DB` repository.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course you can do all this manually, but we have provided a simple API for doing this.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Set the `path_to_repo` directory to the path to your local copy of the `SQuADDS_DB` repository or to where you want it to be. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_to_repo = \"/Users/shanto/LFL/scratch/hf\" #replace with your path to the repo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following method will automatically clone the latest version of the repository (if there are no conflicts) and create (and checkout) a new branch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Already up to date.\n"
     ]
    }
   ],
   "source": [
    "data.update_repo(path_to_repo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can append your validated data to your **selected dataset configuration** by executing the following cell. It also automatically commits and pushes your changes to your fork of the repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data added to qubit-TransmonCross-cap_matrix.json successfully.\n"
     ]
    }
   ],
   "source": [
    "data.update_db(path_to_repo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can upload this updated dataset to your fork of the repository and create a pull request against the original `SQuADDS_DB` repository. Unfortunately, HuggingFace has no API for creating pull requests. You will have to do this step manually by going to your fork of the repository and creating a [pull request](https://huggingface.co/datasets/SQuADDS/SQuADDS_DB/discussions?new_pr=true) against the original `SQuADDS_DB` repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are actively working on setting up an **Acceptance Server** that will make the process of contributing data to SQuADDS project even easier. Users would able to use the following command (post validation) to upload their data to the SQuADDS database and the rest would be handled by the server:\n",
    "\n",
    "```python\n",
    "data.submit()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch Mode for Validation and Submission:\n",
    "\n",
    "In alternative workflow to the previous section, we can also use the SQuADDS API to validate and submit our data in batch mode (i.e. sweep data contribution). This is useful if you have a large number of entries to contribute to the database. The process of contributing multiple entries to the SQuADDS database is the same to the process of contributing a single entry as explained in the previous section.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, we will start by showing how to contribute the same data from [Tutorial 2](https://lfl-lab.github.io/SQuADDS/source/tutorials/Tutorial-2_Simulate_interpolated_designs.html#Simulate-the-Target-Design) to the SQuADDS database using this batch mode process.\n",
    "\n",
    "We assume that in this workflow, you have already studied the schema of the dataset configuration you want to contribute to and have structured your simulation script to output the data in that format which you store in a json file (`examples/single_entry.json`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You still start with the `ExistingConfigData` object like before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "25ebc88e5abf48b48d5d7cdbf3ee1aef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.25k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = ExistingConfigData('qubit-TransmonCross-cap_matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you populate this object with your stored data file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contribution loaded successfully.\n"
     ]
    }
   ],
   "source": [
    "json_file_path = \"examples/single_xmon_lom.json\"\n",
    "data.from_json(json_file_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is always a good idea to validate the entry (even under the assumption that we have created the file with the correct format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f6e59ba72c07456fb266405ce43e6857",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10737ed6f2a5427eb0e8e0ef10d019a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9bbf87ee1bf44018a29197828b109600",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "\n",
      "Missing keys found. These keys are present in one dictionary but not the other:\n",
      "\n",
      "Key: contributor.misc is missing in 'ref'\n"
     ]
    }
   ],
   "source": [
    "data.validate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, an optional key is missing which we can disregard. Now, we can upload this updated dataset to your fork of the repository by executing the following cell.\n",
    "\n",
    "\n",
    "```python\n",
    "    def contribute(self, path_to_repo, is_sweep=False):\n",
    "            \"\"\"\n",
    "            Contributes to the repository by updating the local repo, updating the database, and uploading to HF.\n",
    "\n",
    "            Args:\n",
    "                path_to_repo (str): The path to the repository.\n",
    "                is_sweep (bool): True if the contribution is a sweep, False otherwise.\n",
    "\n",
    "            Returns:\n",
    "                None\n",
    "            \"\"\"\n",
    "            if not self.is_validated:\n",
    "                raise ValueError(\"Data must be validated before contributing.\")\n",
    "            self.update_repo(path_to_repo)\n",
    "            self.update_db(path_to_repo, is_sweep)\n",
    "            print(\"Contribution ready for PR\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Already up to date.\n",
      "Data added to qubit-TransmonCross-cap_matrix.json successfully.\n",
      "Contribution ready for PR\n"
     ]
    }
   ],
   "source": [
    "data.contribute(path_to_repo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same validation and contribution methods can be used for other configurations, we'll take a look at two more examples: the RouteMeander eigenmode and the CapInterdigital capacitance matrix. When working with more than one configuration from the SQuADDS database, it may be helpful in uniquely naming each 'data' variable. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with the RouteMeander eigenmode configuration. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0369001cd3e4458f9d25f93803f6912b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.48k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_eigenmode = ExistingConfigData('cavity_claw-RouteMeander-eigenmode')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this configuration, we will now proceed as we did previously by reading in our data file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contribution loaded successfully.\n"
     ]
    }
   ],
   "source": [
    "json_file_path = \"examples/single_RouteMeander_eigenmode.json\"\n",
    "data_eigenmode.from_json(json_file_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to validate every set of data that you wish to contribute, different configurations might have different acceptable formats. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "\n",
      "Mismatched keys found. These keys are present in both dictionaries but have values of different types:\n",
      "\n",
      "Key: contributor.misc, data type in 'data': <class 'str'>, data type in 'ref': <class 'NoneType'>\n",
      "\n",
      "Missing keys found. These keys are present in one dictionary but not the other:\n",
      "\n",
      "Key: design.design_options.cplr_opts.finger_length is missing in 'data'\n",
      "Key: design.design_options.cplr_opts.cap_gap_ground is missing in 'data'\n",
      "Key: design.design_options.cplr_opts.cap_width is missing in 'data'\n",
      "Key: design.design_options.cplr_opts.cap_distance is missing in 'data'\n",
      "Key: design.design_options.cplr_opts.cap_gap is missing in 'data'\n",
      "Key: design.design_options.cplr_opts.finger_count is missing in 'data'\n",
      "Key: design.design_options.cpw_opts.lead.end_straight is missing in 'data'\n",
      "Key: design.design_options.cpw_opts.lead.start_jogged_extension is missing in 'data'\n"
     ]
    }
   ],
   "source": [
    "data_eigenmode.validate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These missing keys can be ignored in the validation as in the case of this configuration there were more than one acceptable coupler type. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After validation is complete, you can follow the same code as above to contribute your data to the repository to prepare for the final PR."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's see how to configure and validate data for a CapNInterdigital capacitance matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27dddbc4cc5e4823afb50c66e0df5f51",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.48k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_cap = ExistingConfigData('coupler-CapNInterdigitalTee-cap_matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contribution loaded successfully.\n"
     ]
    }
   ],
   "source": [
    "json_file_path = \"examples/single_CapNinterdigital_cap_matrix.json\"\n",
    "data_cap.from_json(json_file_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "\n",
      "Missing keys found. These keys are present in one dictionary but not the other:\n",
      "\n",
      "Key: contributor.misc is missing in 'ref'\n"
     ]
    }
   ],
   "source": [
    "data_cap.validate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the contribution for both of these configurations would be the same as our first example and would look as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_eigenmode.contribute(path_to_repo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_cap.contribute(path_to_repo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Entry (Sweep) Contribution:\n",
    "\n",
    "The same process can be used to contribute multiple entries to the SQuADDS database. The only difference is that you will need to provide a list of data files instead of a single data file.\n",
    "\n",
    "Again, we are making the assumption that you have already studied the schema of the dataset configuration you want to contribute to and have structured your simulation script to output the data in that format which you store in json files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d27c7af22884582ad579f7e93c72e38",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading readme:   0%|          | 0.00/2.25k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = ExistingConfigData('qubit-TransmonCross-cap_matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sweep data loaded successfully.\n"
     ]
    }
   ],
   "source": [
    "json_files_path = \"examples/sweep_data/\"\n",
    "data.from_json(json_files_path,is_sweep=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validating entry 1 of 4...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "11de1019153047f482ba76b01e730d75",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "90b54e351a2744799d72f7d93844b16b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Extracting data files:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a04cf8062d63408d994b8549772f555f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating train split: 0 examples [00:00, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "Entry 1 of 4 validated successfully.\n",
      "--------------------------------------------------\n",
      "Validating entry 2 of 4...\n",
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "Entry 2 of 4 validated successfully.\n",
      "--------------------------------------------------\n",
      "Validating entry 3 of 4...\n",
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "Entry 3 of 4 validated successfully.\n",
      "--------------------------------------------------\n",
      "Validating entry 4 of 4...\n",
      "Structure validated successfully....\n",
      "Types validated successfully....\n",
      "Entry 4 of 4 validated successfully.\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "data.validate_sweep()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Already up to date.\n",
      "Data added to qubit-TransmonCross-cap_matrix.json successfully.\n",
      "Contribution ready for PR\n"
     ]
    }
   ],
   "source": [
    "data.contribute(path_to_repo, is_sweep=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are now ready to make the [Pull Request](https://huggingface.co/datasets/SQuADDS/SQuADDS_DB/discussions?new_pr=true) against the original `SQuADDS_DB` repository.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like that you have now learned how to contribute to an existing dataset configuration in the SQuADDS database! 🎉\n",
    "\n",
    "In the next tutorial, we will learn how to create a new dataset configuration in the SQuADDS database."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## License\n",
    "\n",
    "<div style='width: 100%; background-color:#3cb1c2;color:#324344;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'>\n",
    "    <h3>This code is a part of SQuADDS</h3>\n",
    "    <p>Developed by Sadman Ahmed Shanto & Adhish Chakravorty</p>\n",
    "    <p>This tutorial is written by Sadman Ahmed Shanto & Adhish Chakravorty</p> \n",
    "    <p>&copy; Copyright Sadman Ahmed Shanto & Eli Levenson-Falk 2023.</p>\n",
    "    <p>This code is licensed under the MIT License. You may<br> obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree.</p>\n",
    "    <p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.11.6 ('qiskit_metal')",
   "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.11.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "b0f7559acaf54a9a25b7487b1d76179119f6a08c446a22a42471157036c8af6d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}