___CallistoLab-Lite-3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }/*This file contains any manual css for this page that needs to override the global styles. This is only required when different pages style the same element differently. This is just a hack to deal with our current css styles and no new styling should be added in this file.*/  #ipython-main-app {     position: relative; } #jupyter-main-app {     position: relative; }   /*Hemendik aurrera nik idatzi det*/ body {    font-family: Ubuntu, sans-serif; }  .jupyter-widgets { \tmargin: 5px !important; \tfont-family: Ubuntu, sans-serif !important; }  .jupyter-button { \ttop: 4px !important; \tline-height: 28px !important; }  .widget-text { \tfont-size: 15px !important; }  .output_subarea { \tmargin: auto; }  /*formularioen stylea*/ /* naranja: #fcba05 */ /* gris: #afafaf */  input[type=text] { \tpadding: 3px !important; \tborder: 0 0 0 0; \tborder-bottom-color: #fcba05 !important; \tborder-bottom-width: 2px !important; \t \tborder-top-width: 1px !important; \tborder-left-width: 1px !important; \tborder-right-width: 1px !important; \t \tborder-top-color: transparent !important; \tborder-left-color: transparent !important; \tborder-right-color: transparent !important; }  input[type=text]:hover{ \t     border-top-color: #afafaf !important; \tborder-left-color: #afafaf !important; \tborder-right-color: #afafaf !important; }  input[type=text]:focus{     border-top-color: #fcba05 !important; \tborder-left-color: #fcba05 !important; \tborder-right-color: #fcba05 !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }/*This file contains any manual css for this page that needs to override the global styles. This is only required when different pages style the same element differently. This is just a hack to deal with our current css styles and no new styling should be added in this file.*/  #ipython-main-app {     position: relative; } #jupyter-main-app {     position: relative; }   /*Hemendik aurrera nik idatzi det*/ body {    font-family: Ubuntu, sans-serif; }  .jupyter-widgets { \tmargin: 5px !important; \tfont-family: Ubuntu, sans-serif !important; }  .jupyter-button { \ttop: 4px !important; \tline-height: 28px !important; }  .widget-text { \tfont-size: 15px !important; }  .output_subarea { \tmargin: auto; }  /*formularioen stylea*/ /* naranja: #fcba05 */ /* gris: #afafaf */  input[type=text] { \tpadding: 3px !important; \tborder: 0 0 0 0; \tborder-bottom-color: #fcba05 !important; \tborder-bottom-width: 2px !important; \t \tborder-top-width: 1px !important; \tborder-left-width: 1px !important; \tborder-right-width: 1px !important; \t \tborder-top-color: transparent !important; \tborder-left-color: transparent !important; \tborder-right-color: transparent !important; }  input[type=text]:hover{ \t     border-top-color: #afafaf !important; \tborder-left-color: #afafaf !important; \tborder-right-color: #afafaf !important; }  input[type=text]:focus{     border-top-color: #fcba05 !important; \tborder-left-color: #fcba05 !important; \tborder-right-color: #fcba05 !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.jupyter-button{margin-top:5px} .widget-hbox{min-height:50px} .widget-checkbox .widget-label{width:0px} .widget-checkbox .widget-dropdown{width:0px}"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(HTML(\"<style>.jupyter-button{margin-top:5px} .widget-hbox{min-height:50px} .widget-checkbox .widget-label{width:0px} .widget-checkbox .widget-dropdown{width:0px}\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "//Get the URL of the current notebook\n",
       "\n",
       "var kernel = Jupyter.notebook.kernel; \n",
       "var command = [\"notebook_url = \",\n",
       "               \"'\", window.location.href, \"'\" ].join('')\n",
       "\n",
       "kernel.execute(command)\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%javascript \n",
    "\n",
    "//Get the URL of the current notebook\n",
    "\n",
    "var kernel = Jupyter.notebook.kernel; \n",
    "var command = [\"notebook_url = \",\n",
    "               \"'\", window.location.href, \"'\" ].join('')\n",
    "\n",
    "kernel.execute(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bqplot import *\n",
    "import bqplot as bq\n",
    "import bqplot.marks as bqm\n",
    "import bqplot.scales as bqs\n",
    "import bqplot.axes as bqa\n",
    "from bqplot import pyplot as pyplot\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from IPython.display import display, FileLink, FileLinks\n",
    "import ipywidgets as widgets\n",
    "\n",
    "import qgrid\n",
    "import ipysheet\n",
    "from ipysheet import from_dataframe, to_dataframe\n",
    "\n",
    "from traitlets import link\n",
    "\n",
    "import sys,os\n",
    "import csv\n",
    "\n",
    "import fileupload\n",
    "import io\n",
    "\n",
    "import math\n",
    "\n",
    "import urllib.parse\n",
    "import webbrowser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class dataDB(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.all = {}\n",
    "        self.index = 0\n",
    "        \n",
    "    def add(self, df, name=''):\n",
    "        \n",
    "        if name == '':\n",
    "            name = \"Data \" + str(self.get_last_name())\n",
    "\n",
    "        elif name in self.all.keys():\n",
    "            name = name + \" \" + str(self.get_last_name())\n",
    "        \n",
    "        self.increment_index()\n",
    "\n",
    "        #df = check_df_header(df)\n",
    "        self.all[name] = df\n",
    "        return name\n",
    "    \n",
    "    def update(self, df, name):\n",
    "        self.all[name] = df\n",
    "        \n",
    "    def get(self, name):\n",
    "        if name not in self.all.keys():\n",
    "            return pd.DataFrame({\"x\": float(np.linspace(0.00, 0.00,1)), \"y\": np.linspace(0.00, 0.00,1)})\n",
    "        else:        \n",
    "            return self.all.get(name)\n",
    "    \n",
    "    def remove(self, name):\n",
    "        if len(self.all) > 1:\n",
    "            del self.all[name]\n",
    "        \n",
    "    def get_last_name(self):\n",
    "        return self.index\n",
    "    \n",
    "    def increment_index(self):\n",
    "        self.index = self.index + 1\n",
    "        \n",
    "    def show(self):\n",
    "        return self.all\n",
    "    \n",
    "    def get_datas(self):\n",
    "        return self.all.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_database = dataDB()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mark(object):\n",
    "    \n",
    "    def __init__(self, reg, order, dec):\n",
    "        \n",
    "        self.reg = reg\n",
    "        self.order = order\n",
    "        self.dec = dec\n",
    "        \n",
    "    def update(self, reg, order, dec):\n",
    "        \n",
    "        self.reg = reg\n",
    "        self.order = order\n",
    "        self.dec = dec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Plot(object):\n",
    "    \n",
    "    def __init__(self, name, df, figure, col_x, col_y):\n",
    "        \n",
    "        self.name = name\n",
    "        self.df = df\n",
    "        self.figure = bq.Figure(\n",
    "            title = figure.title,\n",
    "            axes = figure.axes,\n",
    "            marks = figure.marks,\n",
    "            scale_x = figure.scale_x,\n",
    "            scale_y = figure.scale_y,\n",
    "            legend_location = figure.legend_location,\n",
    "            animation_duration = figure.animation_duration,            \n",
    "        )\n",
    "        self.columns = [(col_x, col_y)]\n",
    "        self.marks = [Mark(False, 1, 2)]\n",
    "        \n",
    "    def update(self, name, df, figure, col_x, col_y, marks):\n",
    "        \n",
    "        self.name = name\n",
    "        self.df = df\n",
    "        self.figure = bq.Figure(\n",
    "            title = figure.title,\n",
    "            axes = figure.axes,\n",
    "            marks = figure.marks,\n",
    "            scale_x = figure.scale_x,\n",
    "            scale_y = figure.scale_y,\n",
    "            legend_location = figure.legend_location,\n",
    "            animation_duration = figure.animation_duration,            \n",
    "        )\n",
    "        self.columns.append((col_x, col_y))\n",
    "        \n",
    "        self.marks = marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class plotDB(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.all = {}\n",
    "        self.plots = {}\n",
    "        self.plots_index = 0\n",
    "        \n",
    "    def add_plot(self, df, figure, col_x, col_y, name=''):\n",
    "        if name == '':\n",
    "            name = \"Plot \" + str(self.plots_index)\n",
    "        elif name in self.plots.keys():\n",
    "            name = name + \" \" + str(self.plots_index)\n",
    "        p = Plot(name, df, figure, col_x, col_y)\n",
    "        self.all[name] = p\n",
    "        self.plots[name] = p\n",
    "        \n",
    "        self.plots_index = self.plots_index + 1\n",
    "    \n",
    "    def update_plot(self, df, figure, col_x, col_y, marks, name):\n",
    "        p = self.get_plot(name)\n",
    "        p.update(name, df, figure, col_x, col_y, marks)\n",
    "        self.all[name] = p\n",
    "        self.plots[name] = p\n",
    "        \n",
    "    def save_plot(self, df, figure, name, marks):\n",
    "        p = self.get_plot(name)\n",
    "        p.df = df\n",
    "        p.figure = bq.Figure(\n",
    "            title = figure.title,\n",
    "            axes = figure.axes,\n",
    "            marks = figure.marks,\n",
    "            scale_x = figure.scale_x,\n",
    "            scale_y = figure.scale_y,\n",
    "            legend_location = figure.legend_location,\n",
    "            animation_duration = figure.animation_duration,            \n",
    "        )\n",
    "        p.marks = marks\n",
    "        \n",
    "        self.all[name] = p\n",
    "        self.plots[name] = p\n",
    "    \n",
    "    def get_plot(self, name):\n",
    "        return self.plots.get(name)\n",
    "    \n",
    "    def remove_plot(self, name):\n",
    "        if len(self.plots) > 1:\n",
    "            del self.all[name]\n",
    "            del self.plots[name]\n",
    "            \n",
    "    def get_plots(self):\n",
    "        return self.plots.keys()\n",
    "    \n",
    "    def get_index(self):\n",
    "        return self.plots_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_database = plotDB()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "separators = {\n",
    "    ',':',',\n",
    "    ';':';',\n",
    "    'tab': '\\t',\n",
    "    'whitespace': ' ',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_import_menu(button):\n",
    "    \"\"\"This function is called when a button from\n",
    "    import_buttons_block is clicked and changes the menu showed in \n",
    "    import_menu_block box.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    if button.description == \"OPEN from PC\":\n",
    "        import_menu_block.children = [import_pc_block,]\n",
    "        \n",
    "    elif button.description == \"OPEN from SERVER\":\n",
    "        import_menu_block.children = [import_server_block,]\n",
    "    \n",
    "    elif button.description == \"NEW blank CHART\":\n",
    "        import_menu_block.children = [blank_chart_block,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_csv(file, separator=','):\n",
    "    \"\"\"This function tries to open the csv file \n",
    "    with a given separator and returns a pandas dataframe.\n",
    "    \n",
    "    Returns:\n",
    "        A pandas dataframe if the file could be opened or\n",
    "        None if there was any error.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        df = pd.read_csv(\n",
    "            file,\n",
    "            sep=separator,\n",
    "            dtype=np.float64\n",
    "        )\n",
    "        \n",
    "        return df\n",
    "    \n",
    "    except:\n",
    "        \n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_file_from_pc(change):\n",
    "    \"\"\"This function is called by a FileUpload IPython widget\n",
    "    when a file is uploaded.\n",
    "    It calls to open_csv function with the file provided in\n",
    "    change.owner.data and the separator from\n",
    "    import_pc_separator.value\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    # IMPORTANT:\n",
    "    # THIS FUNCTION HAS BEEN MODIFIED TO WORK WITH FILEUPLOAD\n",
    "    # INSTEAD OF THE FILEUPLOAD IPYTHON WIDGET.\n",
    "    # IN ORDER TO REVERT THE CHANGES THE LINE 18 AND 30 MUST\n",
    "    # BE REPLACED BY THE COMMENTED ONES ABOVE THEM\n",
    "    \n",
    "    button = change.owner\n",
    "\n",
    "    #datastr = str(button.data[0],'utf-8')\n",
    "    datastr = str(button.data,'utf-8')\n",
    "    \n",
    "    datafile = io.StringIO(datastr)\n",
    "    \n",
    "    open_message.value = \"<b>Uploading file...</b>\"\n",
    "    df = open_csv(\n",
    "        datafile,\n",
    "        separators[import_pc_separator.value],\n",
    "    )\n",
    "    \n",
    "    if df is not None:\n",
    "        #filename = list(import_pc_file.value.keys())[0]\n",
    "        filename = button.filename\n",
    "        \n",
    "        open_message.value = \"<span style='color:green'><b>'\" \\\n",
    "                             + filename \\\n",
    "                             + \"' file successfully loaded</b></span>\"\n",
    "        \n",
    "        add_new_data(df)\n",
    "        \n",
    "        main_chart.children = (from_dataframe(df),)\n",
    "\n",
    "        top_block.children = [\n",
    "            open_block,\n",
    "            chart_block\n",
    "        ]\n",
    "        \n",
    "    else:\n",
    "        open_message.value = \"<span style='color:red'><b>An error has occurred, choose another file</b></span>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def import_file_from_server(a):\n",
    "    \"\"\"This function is called by a button IPython widget.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    datafile = import_server_path.value\n",
    "    \n",
    "    open_message.value = \"<b>Opening file...</b>\"\n",
    "    df = open_csv(\n",
    "        datafile,\n",
    "        separators[import_server_separator.value]\n",
    "    )\n",
    "    \n",
    "    if df is not None:\n",
    "        \n",
    "        filename = datafile\n",
    "        open_message.value = \"<span style='color:green'><b>'\" \\\n",
    "                             + filename \\\n",
    "                             + \"' file successfully loaded</b></span>\"\n",
    "        \n",
    "        add_new_data(df)\n",
    "        \n",
    "        main_chart.children = (from_dataframe(df),)\n",
    "        \n",
    "        top_block.children = [\n",
    "            open_block,\n",
    "            chart_block\n",
    "        ]\n",
    "        \n",
    "    else:\n",
    "        open_message.value = \"<span style='color:red'><b>An error has occurred, choose another file</b></span>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_blank_chart(a):\n",
    "    \"\"\"This function creates an empty dataframe with two columns.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    cols = 5\n",
    "    rows = 5\n",
    "    \n",
    "    row = np.array(['' for i in range(cols)])\n",
    "    \n",
    "    df = pd.DataFrame(\n",
    "        [row for i in range(rows)],\n",
    "        columns=list('ABCDE')\n",
    "    )\n",
    "    \n",
    "    open_message.value = \"<span style='color:green'>Chart successfully loaded</b></span>\"\n",
    "    \n",
    "    add_new_data(df)\n",
    "    \n",
    "    sheet = from_dataframe(df)\n",
    "    \n",
    "    main_chart.children = (sheet,)\n",
    "\n",
    "    top_block.children = [\n",
    "            open_block,\n",
    "            chart_block\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_new_data(df):\n",
    "    \"\"\"This function adds a data to the database, replaces the\n",
    "    main_chart dataframe and refreshes the choose_data_dropdown.\n",
    "    \"\"\"\n",
    "    \n",
    "    data_name = data_database.add(df)\n",
    "    \n",
    "    choose_data_dropdown.options = data_database.get_datas()\n",
    "    choose_data_dropdown.value = data_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "open_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        border='solid 1px',\n",
    "        padding='20px',\n",
    "        align_items = 'center'\n",
    "    )\n",
    ")\n",
    "\n",
    "import_buttons_block = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center'\n",
    "    ) \n",
    ")\n",
    "\n",
    "import_menu_block = widgets.HBox(\n",
    "    []\n",
    ")\n",
    "\n",
    "open_message = widgets.HTML(\n",
    "    value = \"\",\n",
    ") \n",
    "\n",
    "open_block.children = [\n",
    "    import_buttons_block,\n",
    "    import_menu_block,\n",
    "    open_message\n",
    "]\n",
    "\n",
    "import_buttons_text = [\n",
    "    \"OPEN from PC\",\n",
    "    \"OPEN from SERVER\",\n",
    "    \"NEW blank CHART\"\n",
    "]\n",
    "\n",
    "import_button_block_children = []\n",
    "\n",
    "for text in import_buttons_text:\n",
    "    \n",
    "    button = widgets.Button(\n",
    "            description = text,\n",
    "            disabled=False,\n",
    "            tooltip='Click me',\n",
    "    )\n",
    "    \n",
    "    button.on_click(change_import_menu)\n",
    "    \n",
    "    import_button_block_children.append(button)\n",
    "\n",
    "import_buttons_block.children = import_button_block_children"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_csv_files(files_dict):\n",
    "    \"\"\"This function find the .csv files avalaiables in the\n",
    "    folder where this file is located.\n",
    "    \n",
    "    Returns:\n",
    "        returns the dict files with the added csv files\n",
    "        dict[file_relative_path] = file_absolute_path\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    root = os.getcwd()\n",
    "\n",
    "    for path, subdirs, files in os.walk(root):\n",
    "        for name in files:\n",
    "            if name.endswith('.csv'):\n",
    "                p = os.path.join(path, name)\n",
    "                f = p.replace(root + os.sep, '')\n",
    "                files_dict[f] = p\n",
    "\n",
    "    return files_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_file_path(change):\n",
    "    import_server_path.value = server_files.get(import_server_files.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upload_file_button():\n",
    "    \"\"\"Create an upload files button\n",
    "    that prints the file name and file size.\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    _upload_widget = fileupload.FileUploadWidget()\n",
    "\n",
    "    def _cb(change):\n",
    "        decoded = io.StringIO(change['owner'].data.decode('utf-8'))\n",
    "        filename = change['owner'].filename\n",
    "\n",
    "    _upload_widget.observe(_cb, names='data')\n",
    "    return _upload_widget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import_pc_block = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center',\n",
    "        width = '100%'\n",
    "    ) \n",
    ")\n",
    "\n",
    "import_pc_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "import_pc_separator = widgets.Dropdown(\n",
    "    options= list(separators),\n",
    "    value=list(separators)[0],\n",
    "    description=\"<h4>Separator: </h4>\",\n",
    "    disabled=False,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "#import_pc_file = widgets.FileUpload(\n",
    "#    accept='',\n",
    "#    multiple=False\n",
    "#)\n",
    "#\n",
    "#import_pc_file.observe(import_file_from_pc, '_counter')\n",
    "\n",
    "import_pc_file_button = upload_file_button()\n",
    "import_pc_file_button.observe(import_file_from_pc, 'data')\n",
    "\n",
    "import_pc_block.children = [\n",
    "    import_pc_name,\n",
    "    import_pc_separator,\n",
    "    #import_pc_file,\n",
    "    import_pc_file_button\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import_server_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center',\n",
    "        width = '100%'\n",
    "    ) \n",
    ")\n",
    "\n",
    "import_server_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "import_server_separator = widgets.Dropdown(\n",
    "    options= list(separators),\n",
    "    value=list(separators)[0],\n",
    "    description=\"<h4>Separator: </h4>\",\n",
    "    disabled=False,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "server_files = { '-Select file-': ''}\n",
    "server_files = get_csv_files(server_files)\n",
    "files_list = list(server_files.keys())\n",
    "\n",
    "\n",
    "import_server_files = widgets.Dropdown(\n",
    "    options= files_list,\n",
    "    #value='',\n",
    "    description=\"<h4>File: </h4>\",\n",
    "    disabled=False,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "import_server_files.observe(update_file_path, 'value')\n",
    "\n",
    "import_server_path = widgets.Text(\n",
    "    value= '',\n",
    "    placeholder=\"Type your file's path:\",\n",
    "    description=\"<h4>Path: </h4>\",\n",
    "    disabled=False,\n",
    "    layout = {'width' : '80%'}\n",
    ")\n",
    "\n",
    "import_server_button = widgets.Button(\n",
    "    description = 'Open file',\n",
    "    disabled=False,\n",
    "    tooltip='',\n",
    "    )\n",
    "    \n",
    "import_server_button.on_click(import_file_from_server)\n",
    "\n",
    "import_server_block.children = [\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            import_server_name,\n",
    "            import_server_separator,\n",
    "            import_server_files\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "            width = '100%'\n",
    "        ) \n",
    "    ),\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            import_server_path,\n",
    "            import_server_button,\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "            width = '100%'\n",
    "        )\n",
    "    )\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "blank_chart_block = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center',\n",
    "        width = '100%'\n",
    "    ) \n",
    ")\n",
    "\n",
    "blank_chart_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "blank_chart_button = widgets.Button(\n",
    "    description = 'New blank chart',\n",
    "    disabled=False,\n",
    "    tooltip='',\n",
    "    )\n",
    "    \n",
    "blank_chart_button.on_click(new_blank_chart)\n",
    "\n",
    "blank_chart_block.children = [\n",
    "    blank_chart_name,\n",
    "    blank_chart_button\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "open_block.children = [\n",
    "    import_buttons_block,\n",
    "    import_menu_block,\n",
    "    open_message\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refresh_column_dropdowns(dropdowns, df):\n",
    "    \"\"\"This function updates the options of all dropdown\n",
    "       IPython widgets given in dropdowns with the columns of \n",
    "       df pandas dataframe.\n",
    "       \n",
    "    \"\"\"\n",
    "    \n",
    "    for dropdown in dropdowns:\n",
    "        dropdown.options = df.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_unique_name(new_name, name_list):\n",
    "    \"\"\"This function checks if new_name is in name_list\n",
    "       and if it is or if new_name = '' returns a string containing\n",
    "       a name that is not present in name_list based on\n",
    "       alphabetical characters.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    if new_name=='' or new_name in name_list:\n",
    "        \n",
    "        alphabet = [\n",
    "            'A','B','C',\n",
    "            'D','E','F',\n",
    "            'G','H','I',\n",
    "            'J','K','L',\n",
    "            'M','N','O',\n",
    "            'P','Q','R',\n",
    "            'S','T','U',\n",
    "            'V','W','X',\n",
    "            'Y','Z'\n",
    "        ]\n",
    "        new_alphabet = [elem for elem in alphabet]\n",
    "        \n",
    "        counter = 0\n",
    "        \n",
    "        while True:\n",
    "            for elem in new_alphabet:\n",
    "                if elem not in name_list:\n",
    "\n",
    "                    return elem\n",
    "            \n",
    "            first_char = alphabet[counter]\n",
    "            \n",
    "            new_alphabet = [first_char+char for char in alphabet]\n",
    "            counter = counter + 1\n",
    "            \n",
    "    else:\n",
    "        \n",
    "        return new_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_column(a):\n",
    "    \"\"\"This function adds an empty column to main_chart using the name\n",
    "       given at new_col_name (if provided).\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    \n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    column_names = df.columns.values\n",
    "    new_col_name = get_unique_name(\n",
    "        new_column_name.value,\n",
    "        column_names\n",
    "    )\n",
    "    \n",
    "    df[new_col_name] = ''\n",
    "    \n",
    "    new_sheet = from_dataframe(df)\n",
    "    main_chart.children = (new_sheet,)\n",
    "    \n",
    "    refresh_column_dropdowns(\n",
    "        column_dropdowns,\n",
    "        df\n",
    "    )\n",
    "    \n",
    "    new_column_name.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_row(a):\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    \n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    cols = list(df.columns)\n",
    "\n",
    "    empty = [['' for i in range(len(cols))]]\n",
    "\n",
    "    empty_row = pd.DataFrame(\n",
    "        empty,\n",
    "        columns = cols\n",
    "    )\n",
    "        \n",
    "    df = df.append(\n",
    "        empty_row,\n",
    "        ignore_index = True\n",
    "    )\n",
    "    \n",
    "    new_sheet = from_dataframe(df)\n",
    "    main_chart.children = (new_sheet,)\n",
    "    \n",
    "    refresh_column_dropdowns(\n",
    "        column_dropdowns,\n",
    "        df\n",
    "    )   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rename_column(a):\n",
    "    \"\"\"This function renames the column selected in\n",
    "       choose_column_dropdown with the name provided in \n",
    "       rename_colomn_name.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    \n",
    "    df = to_dataframe(sheet)\n",
    "    column_names = df.columns.values\n",
    "    \n",
    "    col = choose_column_dropdown.value\n",
    "    \n",
    "    new_name = get_unique_name(\n",
    "        rename_column_name.value,\n",
    "        column_names\n",
    "    )\n",
    "    \n",
    "    df.rename(\n",
    "        columns={col: new_name},\n",
    "        inplace=True\n",
    "    )\n",
    "    \n",
    "    new_sheet = from_dataframe(df)\n",
    "    \n",
    "    main_chart.children = (new_sheet,)\n",
    "\n",
    "    refresh_column_dropdowns(\n",
    "        column_dropdowns,\n",
    "        df\n",
    "    )\n",
    "    \n",
    "    rename_column_name.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_column(a):\n",
    "    \"\"\"This function removes the column selected in\n",
    "       choose_column_dropdown.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    \n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    if len(df.columns.values) > 1:\n",
    "    \n",
    "        col = choose_column_dropdown.value\n",
    "\n",
    "        df.drop(columns=[col], inplace=True)\n",
    "\n",
    "        new_sheet = from_dataframe(df)\n",
    "    \n",
    "        main_chart.children = (new_sheet,)\n",
    "\n",
    "        refresh_column_dropdowns(\n",
    "            column_dropdowns,\n",
    "            df\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_chart_df(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    \n",
    "    old_df_name = change.old\n",
    "    new_df_name = obj.value\n",
    "    \n",
    "    if len(data_database.get_datas()) > 1:\n",
    "        \n",
    "        old_df = to_dataframe(main_chart.children[0])\n",
    "\n",
    "        data_database.update(\n",
    "            old_df,\n",
    "            old_df_name\n",
    "        )\n",
    "    \n",
    "    new_df = data_database.get(new_df_name)\n",
    "    \n",
    "    sheet = from_dataframe(new_df)\n",
    "    \n",
    "    main_chart.children = (sheet,)\n",
    "    \n",
    "    refresh_column_dropdowns(\n",
    "            column_dropdowns,\n",
    "            new_df\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_main_chart(a):\n",
    "    \n",
    "    filename = export_main_chart_name.value\n",
    "    \n",
    "    if filename == '':\n",
    "        filename = choose_data_dropdown.value.replace(' ', '_')\n",
    "        \n",
    "    sheet = main_chart.children[0]\n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    fmt = choose_main_chart_format.value\n",
    "    \n",
    "    export_chart(\n",
    "        df,\n",
    "        fmt,\n",
    "        filename,\n",
    "        export_main_chart_text\n",
    "    )\n",
    "    \n",
    "    export_main_chart_name.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "chart_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        border='solid 1px',\n",
    "        padding='20px',\n",
    "        align_items = 'center',\n",
    "        align_self = 'center',\n",
    "        width='100%'\n",
    "    )\n",
    ")\n",
    "\n",
    "new_column_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"New column's name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "add_column_button = widgets.Button(\n",
    "    #description = 'Add column',\n",
    "    icon = 'plus',\n",
    "    tooltip = 'Add column',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "add_column_button.on_click(add_column)\n",
    "\n",
    "choose_column_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose a column: </h4>',\n",
    "    style = {\n",
    "        'description_width' : 'max-content'\n",
    "    },\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "rename_column_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Column's new name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "rename_column_button = widgets.Button(\n",
    "    #description = 'Rename column',\n",
    "    icon = 'check',\n",
    "    tooltip='Rename column',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "rename_column_button.on_click(rename_column)\n",
    "\n",
    "remove_column_button = widgets.Button(\n",
    "    #description = 'Remove column',\n",
    "    icon = 'times',\n",
    "    tooltip='Remove column',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "remove_column_button.on_click(remove_column)\n",
    "\n",
    "add_row_button = widgets.Button(\n",
    "    #description = 'Add row',\n",
    "    icon = 'plus',\n",
    "    tooltip = 'Add row',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "add_row_button.on_click(add_row)\n",
    "\n",
    "#remove_row_button = widgets.Button(\n",
    "#    description = 'Remove row',\n",
    "#)\n",
    "\n",
    "choose_data_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose a data: </h4>',\n",
    "    style = {\n",
    "        'description_width' : 'initial'\n",
    "    },\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "choose_data_dropdown.observe(change_chart_df, 'value')\n",
    "\n",
    "main_chart = widgets.VBox(\n",
    "        [],\n",
    "        layout = widgets.Layout(\n",
    "            width = '100%',\n",
    "            align_self = 'center',\n",
    "        )\n",
    ")\n",
    "\n",
    "export_main_chart_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"File's name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "choose_main_chart_format = widgets.Dropdown(\n",
    "    options = ['CSV', 'TEX'],\n",
    "    #description='<h4>Choose a plot: </h4>',\n",
    "    style = {'description_width' : 'max-content'},\n",
    "    layout = {'width': 'max-content'}\n",
    ")\n",
    "\n",
    "export_main_chart_button = widgets.Button(\n",
    "    #description = 'Export chart',\n",
    "    tooltip = 'Export chart',\n",
    "    icon = 'download',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "export_main_chart_button.on_click(export_main_chart)\n",
    "\n",
    "export_main_chart_text = widgets.HTML()\n",
    "\n",
    "chart_block.children = [\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            choose_data_dropdown,\n",
    "            widgets.HTML('<h4>Export chart: </h4>'),\n",
    "            export_main_chart_name,\n",
    "            choose_main_chart_format,\n",
    "            export_main_chart_button\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "        )\n",
    "    ),\n",
    "    export_main_chart_text,\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            widgets.HTML('<h4>Rows: </h4>'),\n",
    "            add_row_button,\n",
    "            widgets.HTML('<h4> Columns: </h4>'),\n",
    "            add_column_button,\n",
    "            choose_column_dropdown,\n",
    "            remove_column_button,\n",
    "            rename_column_name,\n",
    "            rename_column_button,\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "        )\n",
    "    ),\n",
    "    main_chart\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_not_number(s):\n",
    "    \"\"\"This function checks if the string s\n",
    "    can be interpreted as a number.\n",
    "    \n",
    "    \"\"\"\n",
    "    try:\n",
    "        float(s)\n",
    "    except:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_column(a):\n",
    "    \"\"\"This function calculates the value of a \n",
    "    column based in an arithmetical operation between\n",
    "    the columns of a dataframe.\n",
    "    \n",
    "    \"\"\"\n",
    "    op = op_col_dropdown.value\n",
    "    c1 = const1.value\n",
    "    c2 = const2.value\n",
    "    c3 = const3.value\n",
    "    c4 = const4.value\n",
    "\n",
    "    if is_not_number(c1) or is_not_number(c2) or is_not_number(c3) or is_not_number(c4):\n",
    "        return None\n",
    "\n",
    "    else:\n",
    "        c1 = float(c1)\n",
    "        c2 = float(c2)\n",
    "        c3 = float(c3)\n",
    "        c4 = float(c4)\n",
    "\n",
    "    df = main_chart.get_changed_df()    \n",
    "        \n",
    "    a = np.array(df[a_col_dropdown.value])\n",
    "    b = np.array(df[b_col_dropdown.value])\n",
    "\n",
    "    with np.errstate(divide='ignore'):\n",
    "        a = a**c2\n",
    "        a[a == np.inf] = 0\n",
    "        a = np.nan_to_num(a)\n",
    "\n",
    "        b = b**c4\n",
    "        b[b == np.inf] = 0\n",
    "        b = np.nan_to_num(b)\n",
    "\n",
    "    if op == '+':\n",
    "        new = c1*a + c3*b\n",
    "\n",
    "    elif op == '-':\n",
    "        new = c1*a - c3*b\n",
    "\n",
    "    elif op == 'x':\n",
    "        new = (c1*a) * (c3*b)\n",
    "\n",
    "\n",
    "    elif op == '/':\n",
    "\n",
    "        with np.errstate(divide='ignore', invalid='ignore'):\n",
    "            c = np.true_divide(c1*a,c3*b)\n",
    "            c[c == np.inf] = 0\n",
    "            new = np.nan_to_num(c)\n",
    "\n",
    "    df[final_col_dropdown.value] = new\n",
    "\n",
    "    main_chart.df = df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#operation_box = widgets.VBox(\n",
    "#    [],\n",
    "#    layout = widgets.Layout(\n",
    "#            align_items = 'center',\n",
    "#        )\n",
    "#)\n",
    "\n",
    "operation_text = widgets.HTML(\n",
    "    value = \"You can operate with the colums: <b>new column = (constant x column1 ^ constant) operation (constant x column2 ^ constant)</b>\"    \n",
    ")\n",
    "\n",
    "final_col_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='100px')\n",
    ")\n",
    "\n",
    "equals = widgets.HTMLMath(\n",
    "    value = '\\( = \\)',\n",
    ")\n",
    "\n",
    "operation_Expression = widgets.HTMLMath(\n",
    "    value = '\\( C1 = a \\cdot C2^{b} * c \\cdot C3^{d}\\)',\n",
    ")\n",
    "\n",
    "power = widgets.HTMLMath(\n",
    "    value = '^',\n",
    ")\n",
    "\n",
    "const1 = widgets.Text(\n",
    "    value='1',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const2 = widgets.Text(\n",
    "    value='1',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const3 = widgets.Text(\n",
    "    value='1',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const4 = widgets.Text(\n",
    "    value='1',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "dot = widgets.HTMLMath(\n",
    "    value = '\\( \\cdot \\)',\n",
    ")\n",
    "\n",
    "a_col_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='100px')\n",
    ")\n",
    "\n",
    "op_col_dropdown = widgets.Dropdown(\n",
    "    options = ['+','-','x','/'],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")\n",
    "\n",
    "b_col_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='100px')\n",
    ")\n",
    "\n",
    "#operate_button = widgets.Button(\n",
    "#    description='Calculate',\n",
    "#    disabled=False,\n",
    "#    button_style='',\n",
    "#    layout = widgets.Layout(\n",
    "#        align_self = 'center'\n",
    "#    )\n",
    "#)\n",
    "#\n",
    "#operate_button.on_click(calculate_column)\n",
    "\n",
    "#operation_box.children = [\n",
    "#    operation_text,\n",
    "#    widgets.HBox([\n",
    "#        final_col_dropdown,\n",
    "#        equals,\n",
    "#        const1,\n",
    "#        dot,\n",
    "#        a_col_dropdown,\n",
    "#        power,\n",
    "#        const2,\n",
    "#        op_col_dropdown,\n",
    "#        const3,\n",
    "#        dot,\n",
    "#        b_col_dropdown,\n",
    "#        power,\n",
    "#        const4,\n",
    "#        operate_button\n",
    "#    ])\n",
    "#]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_operation(a):\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    try:\n",
    "    \n",
    "        df = df.apply(pd.to_numeric)\n",
    "\n",
    "        eq = operation_input.value\n",
    "        df = df.eval(eq, target=df, engine='python')\n",
    "\n",
    "        df = df.fillna('')\n",
    "\n",
    "        new_sheet = from_dataframe(df)\n",
    "        main_chart.children = (new_sheet,)\n",
    "        \n",
    "        hist = list(operation_history.options)\n",
    "        \n",
    "        if eq not in hist:\n",
    "            hist.append(eq)\n",
    "\n",
    "        operation_history.options = hist\n",
    "        operation_history.value = eq\n",
    "                \n",
    "    except:\n",
    "        \n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recover_operation(change):\n",
    "    \n",
    "    op = operation_history.value\n",
    "    operation_input.value = op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "operation_box = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        width = '75%'\n",
    "    )\n",
    ")\n",
    "\n",
    "operation_input = widgets.Textarea(\n",
    "    value='',\n",
    "    placeholder='Type your operation between columns. Use column names. Example: A = B + 2*C',\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(\n",
    "        width = '75%'    \n",
    "    )\n",
    ")\n",
    "\n",
    "operate_button = widgets.Button(\n",
    "    description='Calculate',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    ")\n",
    "\n",
    "operate_button.on_click(run_operation)\n",
    "\n",
    "operation_history = widgets.Select(\n",
    "    options = [''],\n",
    "    value = ''\n",
    ")\n",
    "\n",
    "operation_history.observe(recover_operation, 'value')\n",
    "\n",
    "operation_message = '<b>Available operations:</b>' + \\\n",
    "    '<p>sin, cos, exp, log, expm1, log1p, sqrt,' + \\\n",
    "    ' sinh, cosh, tanh, arcsin, arccos, arctan,' + \\\n",
    "    ' arccosh, arcsinh, arctanh, abs and arctan2</p>' + \\\n",
    "    \"<b>Column names can't contain special characters or spaces</b>\"\n",
    "\n",
    "operation_box.children = [\n",
    "    widgets.VBox([\n",
    "        widgets.HTML('<h4>Operate with columns:</h4>'),\n",
    "        operation_input,\n",
    "        operate_button\n",
    "    ],\n",
    "        layout = widgets.Layout(\n",
    "            width = '90%',\n",
    "        )\n",
    "    ),\n",
    "    widgets.VBox([\n",
    "        widgets.HTML(operation_message),\n",
    "    ]),\n",
    "    widgets.VBox([\n",
    "        widgets.HTML('<h4>Operation history:</h4>'),\n",
    "        operation_history,\n",
    "    ],\n",
    "        layout = widgets.Layout(\n",
    "            width = '90%'\n",
    "        )\n",
    "    )\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_plot(a):\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    df = to_dataframe(sheet)\n",
    "    \n",
    "    x_col_name = x_selector.value\n",
    "    y_col_name = y_selector.value\n",
    "    \n",
    "    x_values = df[x_col_name]\n",
    "    y_values = df[y_col_name]\n",
    "    \n",
    "    min_x, max_x, min_y, max_y = calculate_limits(\n",
    "        x_values,\n",
    "        y_values,\n",
    "        #log_x = log_x,\n",
    "        #log_y = log_y,\n",
    "    )\n",
    "    \n",
    "    \n",
    "    lin_scale_x.min = min_x\n",
    "    lin_scale_x.max = max_x\n",
    "    \n",
    "    #log_scale_x.min = min_x/1.2\n",
    "    #log_scale_x.max = max_x*1.2\n",
    "    \n",
    "    lin_scale_y.min = min_y\n",
    "    lin_scale_y.max = max_y\n",
    "    \n",
    "    #log_scale_y.min = min_y/1.2\n",
    "    #log_scale_y.max = max_y*1.2\n",
    "    \n",
    "    axis_x_name.value = x_col_name\n",
    "    axis_y_name.value = y_col_name\n",
    "    \n",
    "    #log_x = x_scale_dropdown.value == 'Logarithmic scale'\n",
    "    #log_y = y_scale_dropdown.value == 'Logarithmic scale'\n",
    "    \n",
    "    #if log_x:\n",
    "    #    scale_x = log_scale_x\n",
    "    #    \n",
    "    #else:\n",
    "    #    scale_x = lin_scale_x\n",
    "    #    \n",
    "    #if log_y:\n",
    "    #    scale_y = log_scale_y\n",
    "    #    \n",
    "    #else:\n",
    "    #    scale_y = lin_scale_y\n",
    "    #\n",
    "    new_plot = bq.Figure(\n",
    "        title = 'My plot',\n",
    "        axes = main_plot.axes,\n",
    "        marks = [\n",
    "            bqm.Scatter(\n",
    "                x = x_values,\n",
    "                y = y_values,\n",
    "                scales = {'x': lin_scale_x,\n",
    "                          'y': lin_scale_y},\n",
    "                colors = [points_color.value],\n",
    "                labels = ['Scatter 0'],\n",
    "                default_opacities = [1.0]\n",
    "            ),\n",
    "            bqm.Lines(\n",
    "                x = [],\n",
    "                y = [],\n",
    "                scales = {'x': lin_scale_x,\n",
    "                          'y': lin_scale_y},\n",
    "                colors = [points_color.value],\n",
    "                opacities = [1.0]\n",
    "            )\n",
    "        ],\n",
    "        scale_x = lin_scale_x, #main_plot.scale_x,\n",
    "        scale_y = lin_scale_y, #main_plot.scale_y,\n",
    "        legend_location = main_plot.legend_location,\n",
    "        animation_duration = main_plot.animation_duration,            \n",
    "    )\n",
    "    \n",
    "    data = {\n",
    "        x_col_name : x_values,\n",
    "        y_col_name : y_values\n",
    "    }\n",
    "    \n",
    "    new_df = pd.DataFrame(data = data)\n",
    "\n",
    "    plot_database.add_plot(\n",
    "        new_df,\n",
    "        new_plot,\n",
    "        x_col_name,\n",
    "        y_col_name\n",
    "    )\n",
    "    \n",
    "    #plot_chart.df = new_df\n",
    "    \n",
    "    update_plot_dropdown()\n",
    "    choose_plot_dropdown.value = choose_plot_dropdown.options[-1]\n",
    "    \n",
    "    main_block.children = [\n",
    "        top_block,\n",
    "        middle_block\n",
    "    ]\n",
    "    \n",
    "    add_button.disabled = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_to_plot(a):\n",
    "    \n",
    "    sheet = main_chart.children[0]\n",
    "    df = to_dataframe(sheet)\n",
    "\n",
    "    x_col_name = x_selector.value\n",
    "    y_col_name = y_selector.value\n",
    "    \n",
    "    x_values = df[x_col_name]\n",
    "    y_values = df[y_col_name]\n",
    "    \n",
    "    name = choose_plot_dropdown.value\n",
    "    p = plot_database.get_plot(name)\n",
    "\n",
    "    log_x = x_scale_dropdown.value == 'Logarithmic scale'\n",
    "    log_y = y_scale_dropdown.value == 'Logarithmic scale'\n",
    "    \n",
    "    min_x, max_x, min_y, max_y = calculate_limits(\n",
    "        x_values,\n",
    "        y_values,\n",
    "        #log_x = log_x,\n",
    "        #log_y = log_y,\n",
    "    )\n",
    "    \n",
    "    lin_scale_x.min = min(min_x, lin_scale_x.min)\n",
    "    lin_scale_x.max = max(max_x, lin_scale_x.max)\n",
    "    \n",
    "    lin_scale_y.min = min(min_y, lin_scale_y.min)\n",
    "    lin_scale_y.max = max(max_y, lin_scale_y.max)\n",
    "    \n",
    "    log_scale_x.min = min(min_x/1.2, log_scale_x.min)\n",
    "    log_scale_x.max = max(max_x*1.2, log_scale_x.max)\n",
    "    \n",
    "    log_scale_y.min = min(min_y/1.2, log_scale_y.min)\n",
    "    log_scale_y.max = max(max_y*1.2, log_scale_y.max)\n",
    "    \n",
    "    if log_x:\n",
    "        scale_x = log_scale_x\n",
    "    \n",
    "    else:\n",
    "        scale_x = lin_scale_x\n",
    "        \n",
    "    if log_y:\n",
    "        scale_y = log_scale_y\n",
    "        \n",
    "    else:\n",
    "        scale_y = lin_scale_y\n",
    "    #axis_x_name.value = x_col_name\n",
    "    #axis_y_name.value = y_col_name\n",
    "    \n",
    "    label = 'Scatter ' + str(int(len(main_plot.marks)/2))\n",
    "    \n",
    "    main_plot.marks = main_plot.marks + [\n",
    "        bqm.Scatter(\n",
    "            x = x_values,\n",
    "            y = y_values,\n",
    "            scales = {'x': scale_x,\n",
    "                      'y': scale_y},\n",
    "            colors = [points_color.value],\n",
    "            labels = [label],\n",
    "            default_opacities = [1.0]\n",
    "        ),\n",
    "        bqm.Lines(\n",
    "            x = [],\n",
    "            y = [],\n",
    "            scales = {'x': scale_x,\n",
    "                      'y': scale_y},\n",
    "            colors = [points_color.value],\n",
    "            opacities = [1.0]\n",
    "        )\n",
    "    ]    \n",
    "    \n",
    "    data = {\n",
    "        x_col_name : x_values,\n",
    "        y_col_name : y_values\n",
    "    }\n",
    "      \n",
    "    old_df = p.df    \n",
    "    new_df = pd.DataFrame(data = data)\n",
    "    \n",
    "    final_data = {}\n",
    "    \n",
    "    for new_col in new_df.columns:\n",
    "        if new_col not in old_df.columns:\n",
    "            final_data[new_col] = new_df[new_col]\n",
    "    \n",
    "    for old_col in old_df.columns:\n",
    "        final_data[old_col] = old_df[old_col]\n",
    "        \n",
    "    final_df = pd.DataFrame(data = final_data)\n",
    "    \n",
    "    #final_df = pd.concat(\n",
    "    #    [new_df, old_df],\n",
    "    #    axis=1,\n",
    "    #    #ignore_index=True,\n",
    "    #    sort=False,\n",
    "    #)\n",
    "    #\n",
    "    #duplicated = final_df.columns.duplicated()\n",
    "    #\n",
    "    #for repeated in duplicated:\n",
    "    #    if repeated:\n",
    "    #        final_df.drop(index=[repeated])\n",
    "    \n",
    "    #final_df = old_df.append(\n",
    "    #    new_df,\n",
    "    #    #ignore_index=True,\n",
    "    #    sort=False\n",
    "    #)\n",
    "    \n",
    "    \n",
    "    marks = p.marks\n",
    "    marks.append(\n",
    "        Mark(\n",
    "        False,\n",
    "        1,\n",
    "        2\n",
    "        )\n",
    "    )\n",
    "    \n",
    "    plot_database.update_plot(\n",
    "        final_df,\n",
    "        main_plot,\n",
    "        x_col_name,\n",
    "        y_col_name,\n",
    "        marks,\n",
    "        name,\n",
    "    )\n",
    "    \n",
    "    plot_chart.df = final_df\n",
    "    \n",
    "    update_mark_dropdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_plot_dropdown():\n",
    "    \n",
    "    plots = plot_database.get_plots()\n",
    "    choose_plot_dropdown.options = list(plots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_marks(name):\n",
    "    \n",
    "    p = plot_database.get_plot(name)\n",
    "    marks = p.marks\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    marks[i].update(\n",
    "        show_regression_checkbox.value,\n",
    "        regression_order_slider.value,\n",
    "        regression_decimals_dropdown.value\n",
    "    )\n",
    "    \n",
    "    return marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_plot(change):\n",
    "    \n",
    "    old = change.old\n",
    "\n",
    "    if old is not None:\n",
    "        \n",
    "        marks = update_marks(old)\n",
    "        \n",
    "        plot_database.save_plot(\n",
    "            plot_chart.get_changed_df(),\n",
    "            main_plot,\n",
    "            old,\n",
    "            marks\n",
    "        )\n",
    "    \n",
    "    obj = change.owner\n",
    "    value = obj.value\n",
    "\n",
    "    plot = plot_database.get_plot(value)\n",
    "    df = plot.df\n",
    "    figure = plot.figure\n",
    "\n",
    "    plot_chart.df = df\n",
    "    \n",
    "    main_plot.title = figure.title\n",
    "    main_plot.axes = figure.axes\n",
    "    main_plot.marks = figure.marks\n",
    "    main_plot.scale_x = figure.scale_x\n",
    "    main_plot.scale_y = figure.scale_y\n",
    "    main_plot.legend_location = figure.legend_location\n",
    "    main_plot.animation_duration = figure.animation_duration\n",
    "    \n",
    "    \n",
    "    if type(main_plot.scale_x) == bqs.LogScale:\n",
    "        \n",
    "        if type(main_plot.scale_y) == bqs.LogScale:\n",
    "            x_scale_dropdown.value, y_scale_dropdown.value = 'Logarithmic scale', 'Logarithmic scale'\n",
    "            \n",
    "        else:\n",
    "            x_scale_dropdown.value, y_scale_dropdown.value = 'Logarithmic scale', 'Linear scale'\n",
    "        \n",
    "    else:\n",
    "        x_scale_dropdown.value, y_scale_dropdown.value = 'Linear scale', 'Linear scale'\n",
    "\n",
    "    \n",
    "    min_x, max_x, min_y, max_y = calculate_limits(\n",
    "        [mark.x for mark in figure.marks[::2]], #bikoitiak bakarrik! Bakoitiak: puntuak, bikoitiak: erregresioa\n",
    "        [mark.y for mark in figure.marks[::2]],\n",
    "        #log_x = log_x,\n",
    "        #log_y = log_y,\n",
    "    )\n",
    "    \n",
    "    lin_scale_x.min = min_x\n",
    "    lin_scale_x.max = max_x\n",
    "    \n",
    "    lin_scale_y.min = min_y\n",
    "    lin_scale_y.max = max_y\n",
    "    \n",
    "    log_scale_x.min = min_x/1.2\n",
    "    log_scale_x.max = max_x*1.2\n",
    "    \n",
    "    log_scale_y.min = min_y/1.2\n",
    "    log_scale_y.max = max_y*1.2\n",
    "    \n",
    "    save_mark_settings(change)\n",
    "    update_mark_dropdown()\n",
    "    update_mark_settings(None)\n",
    "    \n",
    "    main_block.children = [\n",
    "        top_block,\n",
    "        middle_block\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotter_box = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "        )\n",
    ")\n",
    "\n",
    "y_selector = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h6>Y axis: </h6>',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "x_selector = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h6>X axis: </h6>',\n",
    "    rows = 10,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "points_color = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#7800c8',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "\n",
    "replace_button = widgets.Button(\n",
    "    description = 'New plot',\n",
    ")\n",
    "\n",
    "replace_button.on_click(replace_plot)\n",
    "\n",
    "add_button = widgets.Button(\n",
    "    description = 'Add to plot',\n",
    "    disabled = True\n",
    ")\n",
    "\n",
    "add_button.on_click(add_to_plot)\n",
    "\n",
    "plotter_box.children = [\n",
    "    x_selector,\n",
    "    y_selector,    \n",
    "    points_color,\n",
    "    replace_button,\n",
    "    add_button\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "column_dropdowns = [\n",
    "    final_col_dropdown,\n",
    "    a_col_dropdown,\n",
    "    b_col_dropdown,\n",
    "    choose_column_dropdown,\n",
    "    x_selector,\n",
    "    y_selector\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "chart_block.children = chart_block.children + (operation_box, plotter_box)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "            align_items = 'center',\n",
    "        )\n",
    ")\n",
    "\n",
    "top_block.children = [\n",
    "    open_block,\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_to_file(df, filename, fmt):\n",
    "    \"\"\"This function exports a pandas dataframe\n",
    "    to a selected format (.csv or .tex).\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        if fmt in ['CSV', 'TEX']:\n",
    "\n",
    "            if fmt == 'CSV':\n",
    "\n",
    "                if not filename.endswith('.csv'):\n",
    "                    filename = filename + '.csv'\n",
    "\n",
    "                file = df.to_csv(filename, index=False)\n",
    "\n",
    "                return 'CSV', filename\n",
    "            \n",
    "            if fmt == 'TEX':\n",
    "\n",
    "                if not filename.endswith('.tex'):\n",
    "                    filename = filename + '.tex'\n",
    "\n",
    "                file = df.to_latex(filename, index=False)\n",
    "                \n",
    "                return 'TEX', filename\n",
    "            \n",
    "    except:\n",
    "        \n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_chart(df, fmt, filename, text_widget):\n",
    "    \n",
    "    text_widget.value = \"<b>Creating file...</b>\"\n",
    "    \n",
    "    file, filename = export_to_file(df, filename, fmt)\n",
    "    \n",
    "    if file is not None:\n",
    "        \n",
    "        rel_url = filename\n",
    "        abs_url = urllib.parse.urljoin(notebook_url, rel_url)\n",
    "\n",
    "        if not webbrowser.open(abs_url):\n",
    "            text_widget.value = \"<span style='color:green'><b>\" + file +\" file '\" + filename + \"' successfully created, download it here:</b></span><form action=\" + filename + \" target='_blank'><button type=''submit''>Download</button></form>\"\n",
    "\n",
    "        else:\n",
    "            text_widget.value = \"<span style='color:green'><b>\" + file +\" file '\" + filename + \"' successfully created</b></span>\"\n",
    "        \n",
    "        import_server_files.options = list(\n",
    "            get_csv_files(server_files).keys()\n",
    "        )\n",
    "        \n",
    "    else:\n",
    "        text_widget.value = \"<span style='color:red'><b>An error has occurred</b></span>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def export_plot_chart(a):\n",
    "    \n",
    "    filename = export_plot_chart_name.value\n",
    "    \n",
    "    if filename == '':\n",
    "        filename = choose_plot_dropdown.value.replace(' ', '_')\n",
    "        \n",
    "    df = plot_chart.get_changed_df()\n",
    "    fmt = choose_plot_chart_format.value\n",
    "    \n",
    "    export_chart(\n",
    "        df,\n",
    "        fmt,\n",
    "        filename,\n",
    "        export_plot_chart_text\n",
    "    )\n",
    "    \n",
    "    export_plot_chart_name.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_plot(event, qgrid_widget):\n",
    "    \n",
    "    if event.get('name') == 'cell_edited':\n",
    "    \n",
    "        edited_col = event.get('column')\n",
    "\n",
    "        name = choose_plot_dropdown.value\n",
    "\n",
    "        p = plot_database.get_plot(name)\n",
    "\n",
    "        for i in range(len(p.columns)):\n",
    "\n",
    "            cols = p.columns[i]\n",
    "\n",
    "            col_x = cols[0]\n",
    "            col_y = cols[1]\n",
    "\n",
    "            new_x = plot_chart.get_changed_df()[edited_col]\n",
    "            new_y = plot_chart.get_changed_df()[edited_col] \n",
    "\n",
    "            log_x = x_scale_dropdown.value == 'Logarithmic scale'\n",
    "            log_y = y_scale_dropdown.value == 'Logarithmic scale'\n",
    "            \n",
    "            min_x, max_x, min_y, max_y = calculate_limits(\n",
    "                new_x,\n",
    "                new_y,\n",
    "                #log_x = log_x,\n",
    "                #log_y = log_y\n",
    "            )\n",
    "\n",
    "            if edited_col == col_x:\n",
    "\n",
    "                main_plot.marks[2*i].x = new_x\n",
    "\n",
    "                lin_scale_x.min = min(min_x, lin_scale_x.min)\n",
    "                lin_scale_x.max = max(max_x, lin_scale_x.max)\n",
    "                \n",
    "                log_scale_x.min = min(min_x/1.2, log_scale_x.min)\n",
    "                log_scale_x.max = min(max_x*1.2, log_scale_x.max)\n",
    "    \n",
    "            if edited_col == col_y:\n",
    "\n",
    "                main_plot.marks[2*i].y = new_y\n",
    "\n",
    "                lin_scale_y.min = min(min_y, lin_scale_y.min)\n",
    "                lin_scale_y.max = max(max_y, lin_scale_y.max)\n",
    "                \n",
    "                log_scale_y.min = min(min_y/1.2, log_scale_y.min)\n",
    "                log_scale_y.max = max(max_y*1.2, log_scale_y.max)\n",
    "                \n",
    "    elif event.get('name') in ('row_removed', 'filter_changed'):\n",
    "        \n",
    "        name = choose_plot_dropdown.value\n",
    "\n",
    "        p = plot_database.get_plot(name)\n",
    "        \n",
    "        for i in range(len(p.columns)):\n",
    "\n",
    "            cols = p.columns[i]\n",
    "\n",
    "            col_x = cols[0]\n",
    "            col_y = cols[1]\n",
    "\n",
    "            new_x = plot_chart.get_changed_df()[col_x]\n",
    "            new_y = plot_chart.get_changed_df()[col_y] \n",
    "\n",
    "            log_x = x_scale_dropdown.value == 'Logarithmic scale'\n",
    "            log_y = y_scale_dropdown.value == 'Logarithmic scale'\n",
    "            \n",
    "            min_x, max_x, min_y, max_y = calculate_limits(\n",
    "                new_x,\n",
    "                new_y,\n",
    "                #log_x = log_x,\n",
    "                #log_y = log_y\n",
    "            )\n",
    "\n",
    "            main_plot.marks[i].x = new_x\n",
    "\n",
    "            lin_scale_x.min = min(min_x, lin_scale_x.min)\n",
    "            lin_scale_x.max = max(max_x, lin_scale_x.max)\n",
    "            \n",
    "            log_scale_y.min = min(min_y/1.2, log_scale_y.min)\n",
    "            log_scale_y.max = max(max_y*1.2, log_scale_y.max)\n",
    "\n",
    "            main_plot.marks[i].y = new_y\n",
    "\n",
    "            lin_scale_y.min = min(min_y, lin_scale_y.min)\n",
    "            lin_scale_y.max = max(max_y, lin_scale_y.max)\n",
    "            \n",
    "            log_scale_y.min = min(min_y/1.2, log_scale_y.min)\n",
    "            log_scale_y.max = max(max_y*1.2, log_scale_y.max)\n",
    "            \n",
    "    update_regression(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_tabs = widgets.Tab(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        border='solid 1px',\n",
    "        width='40%'\n",
    "    )    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_chart_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        width='100%',\n",
    "    )    \n",
    ")\n",
    "\n",
    "choose_plot_dropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose a plot: </h4>',\n",
    "    style = {\n",
    "        'description_width' : 'initial'\n",
    "    },\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "choose_plot_dropdown.observe(change_plot, 'value')\n",
    "\n",
    "plot_chart = qgrid.QGridWidget(\n",
    "    df = pd.DataFrame([np.array([0.0, 0.0])], columns=['A', 'B']),\n",
    "    precision = 6,\n",
    "    editable = True,\n",
    "    show_toolbar = True\n",
    ")\n",
    "\n",
    "instances = [\n",
    "    'cell_edited',\n",
    "    'row_removed',\n",
    "    'filter_changed'\n",
    "]\n",
    "\n",
    "plot_chart.on(instances, update_plot)\n",
    "\n",
    "export_plot_chart_name = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"File's name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "choose_plot_chart_format = widgets.Dropdown(\n",
    "    options = ['CSV', 'TEX'],\n",
    "    #description='<h4>Choose a plot: </h4>',\n",
    "    style = {\n",
    "        'description_width' : 'initial'\n",
    "    },\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "export_plot_chart_button = widgets.Button(\n",
    "    #description = 'Export chart',\n",
    "    tooltip = 'Export chart',\n",
    "    icon = 'download',\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "export_plot_chart_button.on_click(export_plot_chart)\n",
    "\n",
    "export_plot_chart_text = widgets.HTML()\n",
    "\n",
    "plot_chart_block.children = [\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            choose_plot_dropdown,\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            width = '90%',\n",
    "        )\n",
    "    ),\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            plot_chart,\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            width = '90%',\n",
    "        )\n",
    "    ),\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            widgets.HTML('<h4>Export chart:</h4>'),\n",
    "            export_plot_chart_name,\n",
    "            choose_plot_chart_format,\n",
    "            export_plot_chart_button,\n",
    "        ],\n",
    "        layout = widgets.Layout(\n",
    "            width = '90%',\n",
    "        )\n",
    "    ),\n",
    "    export_plot_chart_text\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_round(x):\n",
    "    \"\"\"This function returns the nearest 10th power of a\n",
    "    number.\"\"\"\n",
    "    \n",
    "    \n",
    "    if x > 1.0:\n",
    "        return math.ceil(math.log10(x)) #https://www.tutorialspoint.com/python/number_ceil.htm\n",
    "    \n",
    "    else:\n",
    "        for i in range(len(str(x))):\n",
    "            digit = str(x)[i]\n",
    "            if digit != '0' and digit != '.':\n",
    "                return -i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_log_ticks(log_scale):\n",
    "    \n",
    "    min_power = log_round(log_scale.min)\n",
    "    max_power = log_round(log_scale.max)\n",
    "\n",
    "    tick_values = [10**i for i in range(min_power, max_power)]\n",
    "    ticks = []\n",
    "    \n",
    "    for tick in tick_values:\n",
    "        if tick < log_scale_x.max and tick > log_scale_x.min:\n",
    "                ticks.append(tick)\n",
    "                \n",
    "    return ticks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_scale(change):\n",
    "    \"\"\"This function changes the scale of an axis\n",
    "    of main_plot.\n",
    "    \n",
    "    \"\"\"\n",
    "    obj = change.owner\n",
    "    value = obj.value\n",
    "    desc = obj.description\n",
    "\n",
    "    \n",
    "    if value == 'Linear scale':\n",
    "        \n",
    "        if 'X' in desc:\n",
    "            axis_x.scale = lin_scale_x\n",
    "            axis_x.tick_values = None\n",
    "            axis_x.num_ticks = 5\n",
    "        \n",
    "        elif 'Y' in desc:\n",
    "            axis_y.scale = lin_scale_y\n",
    "            axis_y.tick_values = None\n",
    "            axis_y.num_ticks = 4\n",
    "            \n",
    "    elif value == 'Logarithmic scale':\n",
    "\n",
    "        if 'X' in desc:\n",
    "            axis_x.scale = log_scale_x\n",
    "            ticks = generate_log_ticks(log_scale_x)\n",
    "            axis_x.tick_values = ticks\n",
    "        \n",
    "        elif 'Y' in desc:\n",
    "            axis_y.scale = log_scale_y\n",
    "            ticks = generate_log_ticks(log_scale_y)\n",
    "            axis_y.tick_values = ticks\n",
    "\n",
    "    \n",
    "    for mark in main_plot.marks:\n",
    "        mark.scales = {\n",
    "            'x': axis_x.scale,\n",
    "            'y': axis_y.scale\n",
    "        }\n",
    "    \n",
    "    main_plot.scale_x = axis_x.scale\n",
    "    main_plot.scale_y = axis_y.scale\n",
    "    \n",
    "   #right_block.children = [\n",
    "   #    plot_name,\n",
    "   #    widgets.HBox(\n",
    "   #        [\n",
    "   #            axis_x_name,\n",
    "   #            x_scale_dropdown\n",
    "   #        ],\n",
    "   #    ),\n",
    "   #    widgets.HBox(\n",
    "   #        [\n",
    "   #            axis_y_name,\n",
    "   #            y_scale_dropdown\n",
    "   #        ],\n",
    "   #    ),\n",
    "   #    main_plot,\n",
    "   #    mark_dropdown,\n",
    "   #    regression_box,\n",
    "   #    style_box\n",
    "   #]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_limits(x_values, y_values): #, log_x=False, log_y=False):\n",
    "    \"\"\"this function calculates the limits of the axes from\n",
    "    the given values of x and y: a list containing the arrays\n",
    "    of x and y.\n",
    "    \"\"\"\n",
    "\n",
    "    max_x = np.amax(x_values)\n",
    "    min_x = np.min(x_values)\n",
    "\n",
    "    max_y = np.amax(y_values)\n",
    "    min_y = np.min(y_values)\n",
    "\n",
    "    start_x = min_x #- 0.1*abs(max_x - min_x)\n",
    "    end_x = max_x #+ 0.1*abs(max_x - min_x)\n",
    "\n",
    "    start_y = min_y #- 0.1*abs(max_y - min_y)\n",
    "    end_y = max_y #+ 0.1*abs(max_y - min_y)\n",
    "    \n",
    "    #if log_x:\n",
    "    #    \n",
    "    #    start_x = min_x/1.2\n",
    "    #    end_x = max_x*1.2\n",
    "    #    \n",
    "    #if log_y:\n",
    "    #    \n",
    "    #    start_y = min_y/1.2\n",
    "    #    end_y = max_y*1.2\n",
    "        \n",
    "    return start_x, end_x, start_y, end_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "lin_scale_x = bqs.LinearScale(\n",
    "    min = 0,\n",
    "    max = 10,\n",
    "    stabilized = True\n",
    ")\n",
    "\n",
    "lin_scale_y = bqs.LinearScale(\n",
    "    min = 0,\n",
    "    max = 10,\n",
    "    stabilized = True\n",
    ")\n",
    "\n",
    "log_scale_x = bqs.LogScale(min = 1, max = 100)\n",
    "log_scale_y = bqs.LogScale(min = 1, max = 100)\n",
    "\n",
    "axis_x = bqa.Axis(\n",
    "    scale=lin_scale_x,\n",
    "    tick_format='0.2f',\n",
    "    tick_style={'font-size': '15px'},\n",
    "    num_ticks = 5,\n",
    "    grid_lines = 'none',\n",
    "    grid_color = '#8e8e8e', \n",
    "    label='x',\n",
    "    label_location='middle',\n",
    "    label_style={'stroke': 'black', 'default-size': 35},\n",
    "    label_offset='50px'\n",
    ")\n",
    "\n",
    "axis_y = bqa.Axis(\n",
    "    scale=lin_scale_y,\n",
    "    tick_format='0.2f',\n",
    "    tick_style={'font-size': '15px'},\n",
    "    num_ticks = 4,\n",
    "    grid_lines = 'none',\n",
    "    grid_color = '#8e8e8e', \n",
    "    orientation='vertical',\n",
    "    label='y',\n",
    "    label_location='middle',\n",
    "    label_style={'stroke': 'red', 'default_size': 35},\n",
    "    label_offset='50px'\n",
    ")\n",
    "\n",
    "main_plot = bq.Figure(\n",
    "    title='',\n",
    "    marks=[],\n",
    "    axes=[axis_x, axis_y],\n",
    "    animation_duration=500,\n",
    "    layout = widgets.Layout(width='80%', align_self='center'),\n",
    "    legend_location='top-right',\n",
    "    background_style= {'fill': 'white',  'stroke': 'black'},\n",
    "    fig_margin=dict(top=80, bottom=80, left=75, right=20)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_export(a):\n",
    "    \n",
    "    for mark in main_plot.marks:\n",
    "        if mark.selected is not None:\n",
    "            if len(mark.selected) == 0:\n",
    "                mark.selected = None\n",
    "                \n",
    "    main_plot.interaction = None\n",
    "    \n",
    "    global data\n",
    "    \n",
    "    text_lines = []\n",
    "    if len(regression_expression.value) > 7:\n",
    "        text_lines.append(regression_expression.value)\n",
    "        for error in errors_expression.children:\n",
    "            text_lines.append(error.value)\n",
    "    \n",
    "    data = repr((main_plot, text_lines))\n",
    "    %store data\n",
    "\n",
    "    cwd = os.getcwd()\n",
    "    export_button.value = \"<form action=\" + \"../apps/modules/export_module.ipynb\" + \" target='_blank'><button type=''submit''>Open in export module</button></form>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        border='solid 1px',\n",
    "        padding='20px',\n",
    "        align_items = 'center',\n",
    "        width='60%'\n",
    "    )    \n",
    ")\n",
    "\n",
    "plot_name = widgets.Text(\n",
    "    value='My plot',\n",
    "    description=\"<b>Plot's name:</b>\",\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "widgets.jslink((plot_name, 'value'), (main_plot, 'title'))\n",
    "\n",
    "axis_x_name = widgets.Text(\n",
    "    value='x',\n",
    "    description=\"X axis:\",\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "widgets.jslink((axis_x_name, 'value'), (axis_x, 'label'))\n",
    "\n",
    "x_scale_dropdown = widgets.Dropdown(\n",
    "    value = 'Linear scale',\n",
    "    options = ['Linear scale', 'Logarithmic scale'],\n",
    "    description='<h5>X scale: </h5>',\n",
    "    rows = 10,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "x_scale_dropdown.observe(change_scale, 'value')\n",
    "\n",
    "axis_y_name = widgets.Text(\n",
    "    value='y',\n",
    "    description=\"Y axis:\",\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "widgets.jslink((axis_y_name, 'value'), (axis_y, 'label'))\n",
    "\n",
    "y_scale_dropdown = widgets.Dropdown(\n",
    "    value = 'Linear scale',\n",
    "    options = ['Linear scale', 'Logarithmic scale'],\n",
    "    description='<h5>Y scale: </h5>',\n",
    "    rows = 10,\n",
    "    layout={'width': 'max-content'}\n",
    ")\n",
    "\n",
    "y_scale_dropdown.observe(change_scale, 'value')\n",
    "\n",
    "prepare_export_button = widgets.Button(\n",
    "        description='Prepare to export',\n",
    "        disabled=False,\n",
    "        button_style='',\n",
    "        tooltip='',\n",
    "    )\n",
    "\n",
    "prepare_export_button.on_click(prepare_export)\n",
    "\n",
    "export_button = widgets.HTML(\n",
    "    value = \"\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_regression(change):\n",
    "    \n",
    "    if show_regression_checkbox.value:\n",
    "    \n",
    "        i = mark_dropdown.index\n",
    "\n",
    "        x_values = main_plot.marks[2*i].x\n",
    "        y_values = main_plot.marks[2*i].y\n",
    "\n",
    "        order = regression_order_slider.value\n",
    "\n",
    "        reg_x, reg_y, poly, errors = calculate_regression(\n",
    "            x_values,\n",
    "            y_values,\n",
    "            order\n",
    "        )\n",
    "\n",
    "        # Update regression mark\n",
    "        main_plot.marks[2*i+1].x = reg_x\n",
    "        main_plot.marks[2*i+1].y = reg_y\n",
    "\n",
    "        # Update regression expression and errors\n",
    "        reg_exp = '\\(y = \\;\\)'\n",
    "        chars = 'abcdef'\n",
    "\n",
    "        errors_expression.children = []\n",
    "\n",
    "        power = len(poly)\n",
    "\n",
    "        for i in range(len(poly)):\n",
    "            \n",
    "            decimal = regression_decimals_dropdown.value\n",
    "            \n",
    "            coef = np.around([poly[i],],decimal)[0] \n",
    "            error = np.around([errors[i],], decimal)[0]\n",
    "\n",
    "            power = power - 1\n",
    "\n",
    "            if power == 1:\n",
    "\n",
    "                reg_exp = reg_exp + '\\(' + chars[i] + '\\; x \\; + \\; \\)' \n",
    "\n",
    "            elif power == 0:\n",
    "                reg_exp = reg_exp + '\\(' + chars[i] + ' \\)'\n",
    "\n",
    "            else:\n",
    "                reg_exp = reg_exp + '\\(' + chars[i] + '\\; x^{' + str(power) + '} \\; + \\; \\)'\n",
    "\n",
    "            err_exp = '\\(' + chars[i] + '\\; = \\; ' + str(coef) + '\\; \\pm \\;' + str(error) + '\\)'\n",
    "            errors_expression.children = errors_expression.children + (widgets.HTMLMath(value = err_exp),)\n",
    "\n",
    "        regression_expression.value = reg_exp\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        i = mark_dropdown.index\n",
    "        \n",
    "        main_plot.marks[2*i+1].x = []\n",
    "        main_plot.marks[2*i+1].y = []\n",
    "        \n",
    "        errors_expression.children = []\n",
    "        regression_expression.value = '\\(y =\\)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_regression(x_values, y_values, order):\n",
    "    \n",
    "    try:\n",
    "        if len(x_values) > order + 1:\n",
    "            poly, cov = np.polyfit(x_values, y_values, order, cov=True)\n",
    "\n",
    "        else:\n",
    "            poly = np.polyfit(x_values, y_values, len(x_values) - 1)\n",
    "            cov = np.zeros([len(poly),len(poly)])\n",
    "\n",
    "    except:\n",
    "        return None\n",
    "    \n",
    "    reg_x = np.linspace(\n",
    "        start = np.min(x_values),\n",
    "        stop = np.max(x_values),\n",
    "        num = 1000\n",
    "    )\n",
    "    \n",
    "    reg_y = np.polyval(poly, reg_x)\n",
    "    \n",
    "    errors = np.sqrt(np.diag(cov))\n",
    "    \n",
    "    return reg_x, reg_y, poly, errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_mark_dropdown():\n",
    "\n",
    "    mark_dropdown.options = [mark.labels[0] for mark in main_plot.marks[::2]]\n",
    "    #mark_dropdown.value = mark_dropdown.options[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_mark_settings(change):\n",
    "    \n",
    "    ## first we save the old settings\n",
    "    if change is not None:\n",
    "        if change.old is not None:\n",
    "\n",
    "            if 'Scatter' in change.old and change.old in mark_dropdown.options:\n",
    "                plot_name = choose_plot_dropdown.value\n",
    "                p = plot_database.get_plot(plot_name)\n",
    "                marks = p.marks\n",
    "\n",
    "                i = mark_dropdown.options.index(change.old)\n",
    "                mark = marks[i]\n",
    "\n",
    "                mark.reg = show_regression_checkbox.value\n",
    "                mark.order = regression_order_slider.value\n",
    "                mark.dec = regression_decimals_dropdown.value\n",
    "                \n",
    "                plot_database.plots[plot_name].marks[i] = mark\n",
    "                plot_database.all[plot_name].marks[i] = mark\n",
    "    \n",
    "    # then we update the new ones\n",
    "    plot_name = choose_plot_dropdown.value\n",
    "    p = plot_database.get_plot(plot_name)\n",
    "    marks = p.marks\n",
    "\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    if i is not None:\n",
    "        mark = marks[i]\n",
    "        \n",
    "        show_regression_checkbox.value, regression_order_slider.value = mark.reg, mark.order\n",
    "\n",
    "        update_regression(None)\n",
    "        \n",
    "        scat = main_plot.marks[2*i]\n",
    "        reg = main_plot.marks[2*i+1]\n",
    "        \n",
    "        scatter_color.value = scat.default_colors[0]\n",
    "        scatter_opacity.value = scat.default_opacities[0]\n",
    "        scatter_width.value = scat.stroke_width\n",
    "        \n",
    "        regression_color.value = reg.colors[0]\n",
    "        regression_opacity.value = reg.opacities[0]\n",
    "        regression_width.value = reg.stroke_width\n",
    "        \n",
    "        regression_decimals_dropdown.value = mark.dec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_mark_settings(change):\n",
    "\n",
    "    \n",
    "    plot_name = choose_plot_dropdown.value\n",
    "    \n",
    "    if change.old in choose_plot_dropdown.options:\n",
    "\n",
    "        plot_name = change.old\n",
    "    \n",
    "    p = plot_database.get_plot(plot_name)\n",
    "    marks = p.marks\n",
    "    \n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    if i is None:\n",
    "        i = 0\n",
    "        \n",
    "    mark = marks[i]\n",
    "    \n",
    "    mark.reg = show_regression_checkbox.value\n",
    "    mark.order = regression_order_slider.value\n",
    "    mark.dec = regression_decimals_dropdown.value\n",
    "    \n",
    "    plot_database.plots[plot_name].marks[i] = mark\n",
    "    plot_database.all[plot_name].marks[i] = mark\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "mark_dropdown = widgets.Dropdown(\n",
    "    options = [mark.labels[0] for mark in main_plot.marks[::2]],\n",
    "    rows = 10,\n",
    "    layout={\n",
    "        'width': 'max-content',\n",
    "        'align-self': 'center'\n",
    "    },\n",
    "    description='<h4>Choose a mark: </h4>',\n",
    "    style = {'description_width' : 'max-content'},\n",
    ")\n",
    "\n",
    "mark_dropdown.observe(update_mark_settings, 'value')\n",
    "#mark_dropdown.observe(save_mark_settings, 'options')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "regression_box = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center'\n",
    "    )    \n",
    ")\n",
    "\n",
    "show_regression_checkbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show regression',\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "show_regression_checkbox.observe(update_regression, 'value')\n",
    "show_regression_checkbox.observe(save_mark_settings, 'value')\n",
    "\n",
    "regression_order_slider = widgets.IntSlider(\n",
    "    value=1,\n",
    "    min=1,\n",
    "    max=5,\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "regression_order_slider.observe(update_regression, 'value')\n",
    "regression_order_slider.observe(save_mark_settings, 'value')\n",
    "\n",
    "regression_decimals_dropdown = widgets.Dropdown(\n",
    "    options = [i for i in range(0,14)],\n",
    "    value = 2,\n",
    "    layout={'width': 'max-content'}\n",
    "    #description='Number of decimals:',\n",
    ")\n",
    "\n",
    "regression_decimals_dropdown.observe(update_regression, 'value')\n",
    "\n",
    "regression_expression = widgets.HTMLMath(\n",
    "    value = '\\(y =\\)',\n",
    "    description = 'Expression:'\n",
    ")\n",
    "        \n",
    "errors_expression = widgets.VBox([])\n",
    "\n",
    "regression_box.children = [\n",
    "    show_regression_checkbox,\n",
    "    widgets.HBox([\n",
    "        widgets.Label('Order of regression'),\n",
    "        regression_order_slider,\n",
    "    ]),\n",
    "    widgets.HBox([\n",
    "        widgets.Label('Number of decimals:'),\n",
    "        regression_decimals_dropdown,\n",
    "    ]),\n",
    "    regression_expression,\n",
    "    errors_expression\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_scatter_opacity(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "\n",
    "    main_plot.marks[2*i].default_opacities = [obj.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_scatter_color(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    main_plot.marks[2*i].default_colors = [obj.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_scatter_width(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    main_plot.marks[2*i].stroke_width = obj.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_regression_opacity(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "\n",
    "    main_plot.marks[2*i+1].opacities = [obj.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_regression_color(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    main_plot.marks[2*i+1].colors = [obj.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_regression_width(change):\n",
    "    \n",
    "    obj = change.owner\n",
    "    i = mark_dropdown.index\n",
    "    \n",
    "    main_plot.marks[2*i+1].stroke_width = obj.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "style_box = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        align_items = 'center'\n",
    "    )    \n",
    ")\n",
    "\n",
    "data_text = widgets.HTML(\n",
    "    value = '<h4>Data: </h4>'\n",
    ")\n",
    "\n",
    "scatter_color = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#fad87c',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width = '100px')\n",
    ")\n",
    "\n",
    "scatter_color.observe(change_scatter_color, 'value')\n",
    "\n",
    "scatter_opacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=True,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "scatter_opacity.observe(change_scatter_opacity, 'value')\n",
    "\n",
    "scatter_width = widgets.FloatSlider(\n",
    "    value=1.5,\n",
    "    min=0,\n",
    "    max=3.0,\n",
    "    step=0.01,\n",
    "    description='Width:',\n",
    "    disabled=False,\n",
    "    continuous_update=True,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "scatter_width.observe(change_scatter_width, 'value')\n",
    "\n",
    "regression_text = widgets.HTML(\n",
    "    value = '<h4>Regression: </h4>'\n",
    ")\n",
    "\n",
    "regression_color = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#fad87c',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width = '100px')\n",
    ")\n",
    "\n",
    "regression_color.observe(change_regression_color, 'value')\n",
    "\n",
    "\n",
    "regression_opacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=True,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "regression_opacity.observe(change_regression_opacity, 'value')\n",
    "\n",
    "regression_width = widgets.FloatSlider(\n",
    "    value=1.5,\n",
    "    min=0,\n",
    "    max=3.0,\n",
    "    step=0.01,\n",
    "    description='Width:',\n",
    "    disabled=False,\n",
    "    continuous_update=True,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "regression_width.observe(change_regression_width, 'value')\n",
    "\n",
    "style_box.children = [\n",
    "    widgets.HBox([\n",
    "        data_text,\n",
    "        scatter_color,\n",
    "        \n",
    "    ]),\n",
    "    scatter_opacity,\n",
    "    scatter_width,\n",
    "    widgets.HBox([\n",
    "        regression_text,\n",
    "        regression_color,\n",
    "    ]),\n",
    "    regression_opacity,\n",
    "    regression_width\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_settings_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        width='100%'\n",
    "    )    \n",
    ")\n",
    "\n",
    "plot_settings_block.children = [\n",
    "    plot_name,\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            axis_x_name,\n",
    "            x_scale_dropdown\n",
    "        ],\n",
    "    ),\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            axis_y_name,\n",
    "            y_scale_dropdown\n",
    "        ],\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_tabs.children = [\n",
    "    plot_chart_block,\n",
    "    plot_settings_block,\n",
    "    widgets.VBox([\n",
    "        mark_dropdown,\n",
    "        style_box\n",
    "    ]),\n",
    "    widgets.VBox([\n",
    "        mark_dropdown,\n",
    "        regression_box\n",
    "    ]),\n",
    "]\n",
    "\n",
    "right_tabs_titles = [\n",
    "    'Chart',\n",
    "    'Plot settings',\n",
    "    'Marks style',\n",
    "    'Regression'\n",
    "]\n",
    "\n",
    "for i in range(len(right_tabs_titles)):\n",
    "    \n",
    "    right_tabs.set_title(i, right_tabs_titles[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "right_block.children = [\n",
    "    #plot_name,\n",
    "    #widgets.HBox(\n",
    "    #    [\n",
    "    #        axis_x_name,\n",
    "    #        x_scale_dropdown\n",
    "    #    ],\n",
    "    #),\n",
    "    #widgets.HBox(\n",
    "    #    [\n",
    "    #        axis_y_name,\n",
    "    #        y_scale_dropdown\n",
    "    #    ],\n",
    "    #),\n",
    "    main_plot,\n",
    "    widgets.HBox(\n",
    "        [\n",
    "            prepare_export_button,\n",
    "            export_button\n",
    "        ],\n",
    "    ),   \n",
    "    #mark_dropdown,\n",
    "    #regression_box,\n",
    "    #style_box\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "middle_block = widgets.HBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        width='95%'\n",
    "    )    \n",
    ")\n",
    "\n",
    "#middle_block.children = [\n",
    "#    left_block,\n",
    "#    right_block\n",
    "#]\n",
    "\n",
    "middle_block.children = [\n",
    "    right_block,\n",
    "    right_tabs\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "main_block = widgets.VBox(\n",
    "    [],\n",
    "    layout = widgets.Layout(\n",
    "        width='100%'\n",
    "    )    \n",
    ")\n",
    "\n",
    "main_block.children = [\n",
    "    top_block,\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5a34aaecedfc49799d70b9820e260a2e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(VBox(children=(VBox(children=(HBox(children=(Button(description='OPEN from PC', style=ButtonSty…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main_block"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}