NetWorker8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "pd.set_option('max_rows', 100)\n",
    "pd.set_option('max_columns', 100)\n",
    "pd.set_option('display.max_colwidth', 100)\n",
    "pd.set_option('display.column_space', 30)\n",
    "pd.set_option('display.date_dayfirst', True)\n",
    "pd.set_option('display.max_seq_items', 10000)\n",
    "pd.options.display.float_format = '{:20,.2f}'.format\n",
    "import re\n",
    "import json\n",
    "import pprint as pp\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def parse_db(res):\n",
    "    res1 = {}\n",
    "    id=0\n",
    "    \n",
    "    with open(res,encoding='ISO-8859-15') as file: \n",
    "        db = file.read()\n",
    "        \n",
    "    for resource in db.split(';\\n\\n'):\n",
    "        res2 = {}\n",
    "        for attribute in [i.strip() for i in resource.split(';\\n')]:\n",
    "            try: name,value = [i.strip() for i in re.split(':',attribute,maxsplit=1,flags=re.M)]\n",
    "            except ValueError: value += attribute\n",
    "            res2[name] = re.sub('\\\\\\n','',value)\n",
    "        id+=1\n",
    "        res1[id] = res2\n",
    "        \n",
    "    return pd.read_json(json.dumps(dict(res1)),orient='index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_log(res):\n",
    "    columns=['pnum','day','time','id1','id2','id3','id4','id5','id6','server','program','nsr','level','log']\n",
    "    dtypes={'id1':np.int32,'id2':np.int32,'id3':np.int32,'id4':np.int32,'id5':np.int32,'id6':np.int32}\n",
    "\n",
    "    with open(res,'r') as file:\n",
    "        with open(res + \".csv\",'w') as log:\n",
    "            for line in file:\n",
    "                m = re.split('\\s+',line)\n",
    "                line = '&'.join(m[:13]) + '&' + ' '.join(m[13:]) + '\\n'\n",
    "                log.write(line)\n",
    "\n",
    "    log = pd.read_csv(res + \".csv\",sep='&',names=columns,error_bad_lines=False,\n",
    "                        parse_dates={'date':[1,2]})\n",
    "    log.index = pd.to_datetime(log.date, format='%m/%d/%y %H:%M:%S',errors='raise')\n",
    "    log.drop('date',axis=1,inplace=True)\n",
    "    return log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_mminfo(res):\n",
    "    convert = {'B':1,'KB': 1e3,'MB':1e6,'GB':1e9,'TB':1e12}\n",
    "    with open(res,'r') as file:\n",
    "        with open(res + \".csv\",'w') as log:\n",
    "            for line in file:\n",
    "                m = re.split('\\s+',line)\n",
    "                line = '&'.join(m[:11]) + '&' + ' '.join(m[11:]) + '\\n'\n",
    "                log.write(line)\n",
    "\n",
    "    log = pd.read_csv(res + \".csv\",sep='&',error_bad_lines=False,\n",
    "                        parse_dates={'date2':[4,5]},dayfirst=True)\n",
    "    #log.index = pd.to_datetime(log.date2, format='%m/%d/%y %H:%M:%S',errors='coerce')\n",
    "    log['size'] = log.apply(lambda row: row.size1*convert[row.size2], axis=1)\n",
    "    log.drop(['type1','type2','size1','size2'],axis=1,inplace=True)\n",
    "    log.rename({'date2':'date'},axis=1,inplace=True)\n",
    "    log.rename({'sset ':'sset'},axis=1,inplace=True)\n",
    "    del log.index.name\n",
    "    return log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NSRDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nan 'NSR pool' 'NSR client' 'NSR policy' 'NSR schedule' 'NSR device'\n",
      " 'NSR group' 'NSR directive' 'NSR stage' 'NSR label' 'NSR notification'\n",
      " 'NSR usergroup' 'NSR recover' 'NSR lockbox' 'NSR Snapshot Policy'\n",
      " 'NSR Storage Node' 'NSR license' 'NSR auditlog' 'NSR client fix'\n",
      " 'NSR jukebox' 'NSR task' 'NSR' 'NSR Report Home' 'NSR operation status'\n",
      " 'NSR hypervisor' 'NSR NAS discovery task']\n"
     ]
    }
   ],
   "source": [
    "nsrdb = parse_db('DC1-NTW01_nsrdb.out')\n",
    "exclude = ['name','type','ONC program number','ONC transport','ONC version number']\n",
    "writer = pd.ExcelWriter('nsrdb.xlsx')\n",
    "for nsrtype in nsrdb.type.dropna().unique():\n",
    "    res = nsrdb[nsrdb.type==nsrtype].dropna(axis=1)\n",
    "    filter = ['name'] + [col for col in res.columns.tolist() if col not in exclude]\n",
    "    res[filter].to_excel(writer,nsrtype,index=False)\n",
    "writer.save()\n",
    "print(nsrdb.type.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2950"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vols = nsrdb[nsrdb.type==\"NSR jukebox\"].dropna(axis=1).volumes.values[0].split(',')\n",
    "vols = [vol.strip() for vol in vols]\n",
    "len(vols)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# JOBSDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['active job db' 'bootstrap save job' 'index save job' 'job indication'\n",
      " 'notification job' 'recover pipe to save job' 'save job' 'savefs job'\n",
      " 'savegroup job' 'session info' 'synthetic full job' 'utility job']\n"
     ]
    }
   ],
   "source": [
    "jobsdb = parse_db(\"jobquery.txt\")\n",
    "writer = pd.ExcelWriter('jobsdb.xlsx')\n",
    "for nsrtype in jobsdb.type.dropna().unique():\n",
    "    res = jobsdb[jobsdb.type==nsrtype].dropna(axis=1)\n",
    "    res.to_excel(writer,nsrtype,index=False)\n",
    "writer.save()\n",
    "print(jobsdb.type.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 31 entries, APPLI_ACTES to VADP_RH\n",
      "Data columns (total 4 columns):\n",
      "start time           31 non-null int64\n",
      "end time             31 non-null int64\n",
      "completion status    31 non-null object\n",
      "duration             31 non-null int64\n",
      "dtypes: int64(3), object(1)\n",
      "memory usage: 1.2+ KB\n"
     ]
    }
   ],
   "source": [
    "groups = jobsdb[jobsdb.type==\"savegroup job\"].dropna(axis=1)[['name','start time','end time', 'completion status']].groupby('name').first()\n",
    "groups['start time'] = groups['start time'].astype(int,errors='ignore')\n",
    "groups['end time'] = groups['end time'].astype(int,errors='ignore')\n",
    "groups['duration'] = groups['end time'] - groups['start time']\n",
    "groups.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.rcdefaults()\n",
    "fig, ax = plt.subplots(figsize=(10,10))\n",
    "y_pos = np.arange(len(grps))\n",
    "ax.barh(y_pos, groups.duration, left=groups['start time'], align='center', color='green')\n",
    "ax.set_yticks(y_pos)\n",
    "ax.set_yticklabels(groups.index)\n",
    "start = pd.to_datetime(groups['start time'].min(),unit='s')\n",
    "end = pd.to_datetime(groups['end time'].max(),unit='s')\n",
    "ax.set_xticklabels(pd.date_range(start, end, freq='H'), rotation=45)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MMINFO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 10097 entries, 0 to 10096\n",
      "Data columns (total 8 columns):\n",
      "date      10097 non-null datetime64[ns]\n",
      "volume    10097 non-null object\n",
      "client    10097 non-null object\n",
      "ssid      10097 non-null int64\n",
      "flags     10097 non-null object\n",
      "level     10097 non-null object\n",
      "sset      10097 non-null object\n",
      "size      10097 non-null float64\n",
      "dtypes: datetime64[ns](1), float64(1), int64(1), object(5)\n",
      "memory usage: 631.1+ KB\n"
     ]
    }
   ],
   "source": [
    "mminfo = parse_mminfo(\"mminfo.txt\")\n",
    "mminfo.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filter = ((mminfo.level=='full'))\n",
    "mminfo[filter].groupby(['client','sset'])['size'].max().apply(lambda x: x/1e9).nlargest(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter = ((mminfo.level=='full') & (mminfo.sset.str.contains('FULLVM')))\n",
    "mminfo[filter].groupby(['client'])['size'].mean().apply(lambda x: x/1e9).nlargest(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "res1 = mminfo[mminfo.level=='full'].resample('D',on='date')['size'].sum()\n",
    "res2 = mminfo[mminfo.level!='full'].resample('D',on='date')['size'].sum()\n",
    "\n",
    "dailysize = pd.concat([res1,res2],axis=1) / 1e12\n",
    "dailysize.columns = ['full','incr']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(15,13))\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax1.bar(dailysize.index,dailysize.full)\n",
    "ax1.bar(dailysize.index,dailysize.incr,bottom=dailysize.full)\n",
    "plt.legend(('Full', 'Incr'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MMPOOL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 2947 entries, 0 to 2946\n",
      "Data columns (total 2 columns):\n",
      "volume    2947 non-null object\n",
      "pool      2946 non-null object\n",
      "dtypes: object(2)\n",
      "memory usage: 46.1+ KB\n"
     ]
    }
   ],
   "source": [
    "mmpool = pd.read_csv(\"mmpool.txt\",sep=',')\n",
    "mmpool.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>volume</th>\n",
       "      <th>volume</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pool</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1 mois</th>\n",
       "      <td>1426</td>\n",
       "      <td>148.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15 jours</th>\n",
       "      <td>1457</td>\n",
       "      <td>151.53</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7 jours</th>\n",
       "      <td>33</td>\n",
       "      <td>3.43</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Default</th>\n",
       "      <td>30</td>\n",
       "      <td>3.12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          volume               volume\n",
       "pool                                 \n",
       "1 mois      1426               148.30\n",
       "15 jours    1457               151.53\n",
       "7 jours       33                 3.43\n",
       "Default       30                 3.12"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = mmpool.groupby('pool').count()\n",
    "pd.concat([res, res * 104 / 1e3],axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DAEMONLOG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 87877 entries, 2018-03-27 17:00:07 to 2018-04-10 13:04:25\n",
      "Data columns (total 12 columns):\n",
      "pnum       87877 non-null int64\n",
      "id1        87877 non-null int64\n",
      "id2        87877 non-null int64\n",
      "id3        87877 non-null int64\n",
      "id4        87877 non-null int64\n",
      "id5        87877 non-null int64\n",
      "id6        87877 non-null int64\n",
      "server     87877 non-null object\n",
      "program    87877 non-null object\n",
      "nsr        87877 non-null object\n",
      "level      87877 non-null object\n",
      "log        87877 non-null object\n",
      "dtypes: int64(7), object(5)\n",
      "memory usage: 8.7+ MB\n"
     ]
    }
   ],
   "source": [
    "log = parse_log(\"daemon.logs/2/lastlog\")\n",
    "log.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['nsrd', 'nsrexecd', 'nsrmmdbd', 'nsrdispd', 'nsrjobd', 'nsrindexd',\n",
       "       'nsrmmgd', 'nsrsnmd', 'nsrvmwsd', 'nsrlcpd#1', 'nsrmmd', 'nsrpsd',\n",
       "       'savegrp', 'nsrtask', 'nsrdisp_nwbg', 'nsrim'], dtype=object)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log.program.unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## groups"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filter = (log.program=='nsrd') & (log.log.str.contains(\"Starting the group\"))\n",
    "started = log.log[filter].reset_index()\n",
    "started[['group','clients']] = started.log.str.split(' ',expand=True)[[5,8]]\n",
    "started.group = started.group.apply(lambda x: re.sub('[\\',.]','',x))\n",
    "started.drop('log',axis=1,inplace=True)\n",
    "started.rename({'date':'started'},axis=1,inplace=True)\n",
    "started['session'] = started.groupby('group').cumcount()\n",
    "\n",
    "range_session = {g:0 for g in started.group.unique()}\n",
    "\n",
    "def calcul_session(row):\n",
    "    start = started[started.group==row.group].iloc[0]\n",
    "    if start.started > row.completed: res =  -1  \n",
    "    else:\n",
    "        res = range_session[row.group]\n",
    "        range_session[row.group]+=1\n",
    "    return res\n",
    "\n",
    "r_clients = re.compile('Total (\\d+) client\\(s\\)')\n",
    "r_Unresolved = re.compile('(\\d+) Hostname\\(s\\) Unresolved')\n",
    "r_Warnings = re.compile('(\\d+) Succeeded with warning\\(s\\)')\n",
    "r_Succeeded = re.compile('(\\d+) Succeeded')\n",
    "r_Failed = re.compile('(\\d+) Failed')\n",
    "\n",
    "def parse_savegrouplog(row):\n",
    "    for line in row.log.split(','):\n",
    "        line = line.strip()\n",
    "        res = re.match(r_clients,line)\n",
    "        if res: row['Clients'] = int(res.group(1))\n",
    "        res = re.match(r_Unresolved,line); \n",
    "        if res: row['Unresolved'] = int(res.group(1))\n",
    "        res = re.match(r_Warnings,line)\n",
    "        if res: row['Warnings'] = int(res.group(1))\n",
    "        res = re.match(r_Succeeded,line)\n",
    "        if res: row['Succeeded'] = int(res.group(1))\n",
    "        res = re.match(r_Failed,line)\n",
    "        if res: row['Failed'] = int(res.group(1))\n",
    "    return row\n",
    "\n",
    "filter = (log.program=='nsrd') & ((log.log.str.contains(\"completed,\")) | (log.log.str.contains(\"aborted,\")) | (log.log.str.contains(\"terminée,\")))\n",
    "completed = log.log[filter].str.split('notice:|alert:|Alert:|completed,|aborted,|terminée,|\\.',expand=True).reset_index()\n",
    "completed = completed[['date',0,1,2]].rename({'date':'completed',0:'type',1:'group',2:'log'},axis=1)\n",
    "completed[['type','group']] = completed[['type','group']].apply(lambda x: x.str.strip(),axis=1)\n",
    "completed = completed[completed.type==\"savegroup\"].reset_index(drop=True)\n",
    "completed.drop(completed[completed.log.str.contains(\"already running\")].index,inplace=True)\n",
    "completed = completed.apply(parse_savegrouplog,axis=1).fillna(0)\n",
    "completed['session'] = completed.groupby('group').cumcount()\n",
    "#completed['session'] = completed.apply(calcul_session,axis=1)\n",
    "\n",
    "groups = pd.merge(started,completed,how='left',on=['group','session'])\n",
    "#groups = pd.concat([started,completed],axis=1)\n",
    "groups['duration'] =  groups.completed - groups.started\n",
    "\n",
    "grp = pd.DataFrame(groups.group.unique()).reset_index().rename({'index':'num',0:'group'},axis=1)\n",
    "groups = pd.merge(groups,grp,how='left',on='group')\n",
    "#groups = groups[~groups.completed.isna()]\n",
    "groups['ratio'] = groups.Failed/groups.Clients\n",
    "groups = groups[['session','num','group','started','completed','duration','Clients','Failed','Succeeded','Unresolved','Warnings','ratio']]\n",
    "\n",
    "\n",
    "# filter = (log.program=='nsrd') & (log.log.str.contains(\"savegroup alert\"))\n",
    "# res = log.log[filter].str.split('alert:|completed,|aborted,|terminée,|\\.',expand=True).reset_index()\n",
    "# res = res[['date',1,2]].rename({1:'group',2:'log'},axis=1)\n",
    "# res = res.apply(parse_savegrouplog,axis=1).fillna(0)\n",
    "\n",
    "# groups = pd.merge(groups,res,how='left',left_on=['group','completed'],right_on=['group','date'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Percent failed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "group\n",
       "APPLI_ACTES                            0.18\n",
       "APPLI_REFERENCE_TEST                   0.13\n",
       "APPLI_FICHIERS                         0.05\n",
       "VADP_Infra                             0.04\n",
       "VADP_MINFRA                            0.03\n",
       "VADP_DEMAT                             0.02\n",
       "APPLI_RH                               0.02\n",
       "VADP_BO                                0.01\n",
       "VADP_REFERENCE_TEST                    0.01\n",
       "APPLI_ACTES_TEST                       0.00\n",
       "Name: ratio, dtype: float64"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groups.groupby('group').ratio.mean().nlargest(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(groups.groupby('group').ratio.mean().sum() / len(groups.group.unique()) * 100,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x1300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(15,13))\n",
    "ax1 = fig.add_subplot(111)\n",
    "\n",
    "grplist = groups.groupby('group').num.first().sort_values().reset_index()\n",
    "\n",
    "xtick = pd.date_range(groups.started.min(), groups.completed.max(), freq='D')\n",
    "daysFmt = mdates.DateFormatter('%d-%m-%Y')\n",
    "ax1.set_yticks(grplist.num)\n",
    "ax1.set_yticklabels(grplist.group)\n",
    "ax1.set_xlim(groups.started.min(), groups.completed.max())\n",
    "ax1.set_xticklabels(xtick,rotation=45)\n",
    "ax1.xaxis.set_major_formatter(daysFmt)\n",
    "for i in range(len(groups.session)):\n",
    "    grp = groups[groups.session==i]\n",
    "    ax1.barh(grp.num, grp.duration, left=grp.started, color='green',edgecolor='black')\n",
    "    ax1.barh(grp.num, grp.duration*grp.ratio, left=grp.started, color='red')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for level in log.level[log.level.notna()].unique():\n",
    "    print('-'*10 + level + '-'*10)\n",
    "    print(log.log[log.level==level].value_counts()[:10].reset_index())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### waiting volume"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "filter = ((log.log.str.contains(\"Media Critical event\")) & (~log.log.str.contains(\"LTO Ultrium-4\")))\n",
    "tapes = log.log[filter].str.split(':|[Ww]aiting for|writable|tape|\\'',expand=True)\n",
    "tapes = tapes[[2,4]].rename({2:'waiting',4:'pool'},axis=1)\n",
    "tapes['waiting'] = tapes.waiting.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>waiting</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-03-27 20:00:00</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-27 21:00:00</th>\n",
       "      <td>103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-27 22:00:00</th>\n",
       "      <td>435</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-27 23:00:00</th>\n",
       "      <td>1095</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-03-28 00:00:00</th>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     waiting\n",
       "date                        \n",
       "2018-03-27 20:00:00        1\n",
       "2018-03-27 21:00:00      103\n",
       "2018-03-27 22:00:00      435\n",
       "2018-03-27 23:00:00     1095\n",
       "2018-03-28 00:00:00      163"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tapes.resample('H').sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### drives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "daterange = (log.index > '03/31/18 16:00') & (log.index < '04/6/18 16:00')\n",
    "filter = ( daterange &(log.program=='nsrmmgd') & (log.log.str.contains(\"Loading\")))\n",
    "loading = log.log[filter].str.split('volume|\\'|\\`',expand=True).reset_index()\n",
    "loading = loading[['date',2,6]].rename({'date':'loading',2:'tape',6:'drive'},axis=1)\n",
    "loading[['tape','drive']] = loading[['tape','drive']].apply(lambda x: x.str.strip(),axis=1)\n",
    "loading['session'] = loading.groupby('drive').cumcount()\n",
    "\n",
    "range_session = {g:0 for g in loading.drive.unique()}\n",
    "\n",
    "def calcul_session(row):\n",
    "    start = loading[loading.drive==row.drive].iloc[0]\n",
    "    if start.loading > row.unloading: res =  -1  \n",
    "    else:\n",
    "        res = range_session[row.drive]\n",
    "        range_session[row.drive]+=1\n",
    "    return res\n",
    "\n",
    "filter = (daterange & (log.program=='nsrmmgd') & (log.log.str.contains(\"Unloading\")))\n",
    "unloading = log.log[filter].str.split('volume|\\'|\\`',expand=True).reset_index()\n",
    "unloading = unloading[['date',2,4]].rename({'date':'unloading',2:'tape',4:'drive'},axis=1)\n",
    "unloading[['tape','drive']] = unloading[['tape','drive']].apply(lambda x: x.str.strip(),axis=1)\n",
    "#unloading['session'] = unloading.groupby('drive').cumcount()\n",
    "unloading['session'] = unloading.apply(calcul_session, axis=1)\n",
    "\n",
    "drives = pd.merge(loading,unloading,how='left',on=['drive','session'])\n",
    "drives['duration'] = drives.unloading - drives.loading\n",
    "#drives['session'] = drives.groupby('drive').cumcount()\n",
    "\n",
    "drvlist = pd.DataFrame(drives.drive.unique()).sort_values(by=0).reset_index()\n",
    "drvlist = drvlist.rename({'index':'num',0:'drive'},axis=1)\n",
    "\n",
    "drives = pd.merge(drives,drvlist,how='left',on='drive')\n",
    "\n",
    "#filter = (drives.duration > pd.Timedelta(np.timedelta64(1, 'm')))\n",
    "drives = drives.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x1300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(15,13))\n",
    "ax1 = fig.add_subplot(111)\n",
    "\n",
    "xtick = pd.date_range(drives.loading.min(), drives.unloading.max(), freq='D')\n",
    "daysFmt = mdates.DateFormatter('%d-%m-%Y')\n",
    "ax1.set_yticks(drvlist.num)\n",
    "ax1.set_yticklabels(drvlist.drive)\n",
    "ax1.set_xlim(drives.loading.min(), drives.unloading.max())\n",
    "ax1.set_xticklabels(xtick,rotation=45)\n",
    "ax1.xaxis.set_major_formatter(daysFmt)\n",
    "for i in range(len(drives.session)):\n",
    "    drv = drives[drives.session==i]\n",
    "    ax1.barh(drv.num, drv.duration, left=drv.loading, color='green',edgecolor='black')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ssets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "minus = re.compile('(.+)done saving to pool.+')\n",
    "equals = re.compile('.+\\s[KMGT]B')\n",
    "\n",
    "def count_save(row):\n",
    "    if re.match(minus,row.log): res=-1\n",
    "    elif re.match(equals,row.log): res=0\n",
    "    else: res=1\n",
    "    return res\n",
    "\n",
    "filter = (log.program=='nsrd') & (log.log.str.contains(\"saving to pool\"))\n",
    "res = log.log[filter].reset_index()\n",
    "res['cnt'] = res.apply(count_save,axis=1)\n",
    "\n",
    "res = pd.concat([res[['date','cnt']],\n",
    "                 res.log.str.split('saving|done|\\'|\\(|\\)',expand=True)[[0,6]]],\n",
    "                  axis=1).rename({0:'sset',6:'size'},axis=1)\n",
    "\n",
    "range_session = {g:0 for g in res.sset.unique()}\n",
    "def calcul_session(row):\n",
    "    res = range_session[row.sset]\n",
    "    if row.cnt==1: range_session[row.sset]+=1\n",
    "    if row.cnt==-1: res = res-1\n",
    "    if row.cnt==0: res=-1\n",
    "    return res\n",
    "\n",
    "res['session'] = res.apply(calcul_session,axis=1)\n",
    "res = res[res.session!=-1]\n",
    "res = res.groupby(['session','sset']).agg({'date': ['min', 'max'], 'size': 'last' },group_keys=False).reset_index()\n",
    "\n",
    "resize = {'B':1,'KB':1e3,'MB':1e6,'GB':1e9,'TB':1e12}\n",
    "def convert_size(row):\n",
    "    try: res=int(row[1])*resize[row[2]]\n",
    "    except ValueError: res=0\n",
    "    return res\n",
    "\n",
    "\n",
    "res['size'] = res['size']['last'].str.split(' ',expand=True).apply(convert_size,axis=1)\n",
    "\n",
    "res = pd.concat([res,res.sset.str.split(':',n=1,expand=True)],axis=1)\n",
    "res.columns = ['session','sset1','start','end','size','client','sset']\n",
    "res['duration'] = res.apply(lambda row: row.end-row.start,axis=1)\n",
    "\n",
    "ssets = res[['session','client','sset','start','duration','size']]\n",
    "bandwith = ssets.resample('H',on='start').sum()['size'] / 1e12\n",
    "sessions = ssets.resample('H',on='start').count()['session']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,6))\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax1.bar(sessions.index,sessions)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,6))\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax1.plot(bandwith)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ssets[ssets.session>40].groupby(['client','sset']).session.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = ssets.groupby(['client','sset'])['size'].max().reset_index().nlargest(10,'size')\n",
    "res['size (GB)'] = ([int(x) for x in res['size'] / 1e9])\n",
    "del res['size']\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = ssets.groupby(['client','sset'])['duration'].max().reset_index().nlargest(10,'duration')\n",
    "# res['size (GB)'] = ([int(x) for x in res['size'] / 1e9])\n",
    "# del res['size']\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## volumes"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "71193 03/28/18 00:02:47  0 0 0 3400 3396 0 dc1-ntw01 nsrd NSR info Deleted media Notice: Deleted volume: volid=2120324013, volname=~1522195365~B01735, pool=1 mois, location=? \n",
    "71193 03/28/18 00:20:37  0 0 0 3400 3396 0 dc1-ntw01 nsrd NSR info Media Notice: LTO Ultrium-4 tape B02906 on \\\\.\\Tape5 is full "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f1b034eb908>"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEQCAYAAABFtIg2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzt3XmYXGWZ9/HvXUtv2bqzhyRNEhKWAGFrIMiwBwi4IIoODsoyjlEHkMFRBHFBAffXdRCNioiKiAtjBiIRZFMUSMIekkiAmM5GEpI0SXqvut8/zqlOdXdVJ71UVVfq97muurrqOU+duvt0dd31LOc55u6IiIhkEil0ACIiMngpSYiISFZKEiIikpWShIiIZKUkISIiWSlJiIhIVkoSIiKSlZKEiIhkpSQhIiJZxQodQH+NHj3ap0yZUugwRESKytKlS7e4+5g91Sv6JDFlyhSWLFlS6DBERIqKmf1zb+qpu0lERLJSkhARkayUJEREJCslCRERyWrQJQkzm2tmK81slZldW+h4RERK2aBKEmYWBW4BzgFmAu8zs5mFjUpEpHQNqiQBHAescvdX3b0VuAs4Lxcv9Oflr7PgufW52LWIyD5jsCWJiUB92uO1YVknZjbPzJaY2ZLNmzf36YV+9dQabn3klb5FKSJSIgZbkrAMZd0uwu3u8929zt3rxozZ4wmDGY0ZVsHmHS19eq6ISKkYbEliLTA57fEkICd9QhOrK9iys4WdLe252L2IyD5hsCWJxcAMM5tqZmXAhcCCXLzQQeOHA7By445c7F5EZJ8wqJKEu7cDVwCLgOXA3e6+LBevdfD4YQCs2PhmLnYvIrJPGHQL/Ln7QmBhrl9nYnUllfEoqzbtzPVLiYgUrUHVksinSMSYMnoIq7fsKnQoIiKDVskmCYAhZVFa2pOFDkNEZNAq6SQRiRiJZLcZtiIiEirpJBFTkhAR6VFJJ4loxEi4koSISDYlnSQiZiTVkhARyaqkk0QsYrQrSYiIZFXSSUID1yIiPSvpJBE1I6kxCRGRrEo7SUTV3SQi0pPSThIauBYR6VFJJ4mYpsCKiPSopJNEJGIkEkoSIiLZlHSSiJpaEiIiPSntJBE1ElrfT0Qkq9JOEmYkksoSIiLZlHaS0Ml0IiI9KvkkoRwhIpJdySeJdnU3iYhkVdJJIlgFttBRiIgMXiWdJGJqSYiI9ChnScLMvm5mK8zseTO7x8yq07ZdZ2arzGylmZ2dVj43LFtlZtfmKraUSDgm4TpXQkQko1y2JB4ADnP3WcA/gOsAzGwmcCFwKDAX+L6ZRc0sCtwCnAPMBN4X1s2ZWMQANHgtIpJFzpKEu//J3dvDh08Ak8L75wF3uXuLu78GrAKOC2+r3P1Vd28F7grr5kw0TBLqchIRySxfYxL/DvwxvD8RqE/btjYsy1aeMxELWxLKESIiGcX682QzexAYn2HT9e7+h7DO9UA78MvU0zLUdzInrIwdQWY2D5gHUFtb28uod4t1aklE+7wfEZF9Vb+ShLvP6Wm7mV0CvA04w3ePDq8FJqdVmwSsD+9nK+/6uvOB+QB1dXV9HlGIRYMkobOuRUQyy+XsprnAp4B3uHtj2qYFwIVmVm5mU4EZwFPAYmCGmU01szKCwe0FuYoPdrck2rRcuIhIRv1qSezB/wDlwAMW9P0/4e4fcfdlZnY38BJBN9Tl7p4AMLMrgEUEfT+3ufuyHMZHLBrkSA1ci4hklrMk4e7Te9h2M3BzhvKFwMJcxdRVx+wmtSRERDIq6TOu49HUwLWShIhIJiWdJGKR4NfXNSVERDIr8SShgWsRkZ6UdpKIploSShIiIpmUdpLoaEmou0lEJJPSThIauBYR6VFJJ4ndazcpSYiIZKIkASR0PQkRkYxKOkmkTqbTDFgRkcxKOkmEOYKkWhIiIhmVdpKIqLtJRKQnJZ0kohq4FhHpUWknCV3jWkSkRyWdJMKGhM64FhHJoqSTxO6WhJKEiEgmpZ0kTJcvFRHpSUkniYhaEiIiPSrtJGFKEiIiPSnpJLG7u6nAgYiIDFIlnSTCC9OpJSEikkVpJwmdTCci0qOSThIxLcshItKjnCcJM/uEmbmZjQ4fm5l918xWmdnzZnZ0Wt1LzOzl8HZJrmNLnSehKbAiIpnFcrlzM5sMnAmsSSs+B5gR3o4HbgWON7ORwOeBOsCBpWa2wN235Sq+WDgo0Z5QkhARySTXLYlvAdcQfOinnAfc4YEngGozmwCcDTzg7lvDxPAAMDeXwUWjakmIiPQkZ0nCzN4BrHP357psmgjUpz1eG5ZlK8+Z1JiErnEtIpJZv7qbzOxBYHyGTdcDnwbOyvS0DGXeQ3mm150HzAOora3dq1gz6Ri41qXpREQy6leScPc5mcrN7HBgKvCcBdNMJwFPm9lxBC2EyWnVJwHrw/JTu5Q/kuV15wPzAerq6vrcDEgNXLdpTEJEJKOcdDe5+wvuPtbdp7j7FIIEcLS7bwQWABeHs5xmAw3uvgFYBJxlZjVmVkPQClmUi/hSzIxYxGhXS0JEJKOczm7KYiFwLrAKaAQuA3D3rWZ2I7A4rPdFd9+a62Di0Qit7UoSIiKZ5CVJhK2J1H0HLs9S7zbgtnzElFIWU5IQEcmmpM+4hjBJaIU/EZGMSj5JlMcitLQpSYiIZFLySaIiHqW5PVHoMEREBiUliXiEZrUkREQyUpKIRWluU0tCRCQTJYm4koSISDYlnyTKYxFaNAVWRCSjkk8S0YhpFVgRkSyUJJQkRESyKvkkEY9GaNPJdCIiGZV8ktAUWBGR7Eo+SZTHdDKdiEg2JZ8kKuJalkNEJBsliXBZjmBxWhERSVfySaI8FsFdV6cTEcmk5JNEPBocAs1wEhHpruSTRFksOAS68JCISHclnyRiYUuiXSfUiYh0U/JJImoGoLOuRUQyUJIIj0BCs5tERLpRkogEhyCh2U0iIt0oSaglISKSVU6ThJldaWYrzWyZmX0trfw6M1sVbjs7rXxuWLbKzK7NZWwpHS2JpGY3iYh0FcvVjs3sNOA8YJa7t5jZ2LB8JnAhcCiwH/CgmR0YPu0W4ExgLbDYzBa4+0u5ihHSB65z+SoiIsUpZ0kC+CjwFXdvAXD3TWH5ecBdYflrZrYKOC7ctsrdXwUws7vCurlNEpEgSbSrJSEi0k0uu5sOBE4ysyfN7FEzOzYsnwjUp9VbG5ZlK+/GzOaZ2RIzW7J58+Z+BZlKEsoRIiLd9aslYWYPAuMzbLo+3HcNMBs4FrjbzKYBlqG+kzlhZRxNdvf5wHyAurq6fo04a+BaRCS7fiUJd5+TbZuZfRT4vQfLqz5lZklgNEELYXJa1UnA+vB+tvKciehkOhGRrHLZ3fS/wOkA4cB0GbAFWABcaGblZjYVmAE8BSwGZpjZVDMrIxjcXpDD+IDdSUJLhYuIdJfLgevbgNvM7EWgFbgkbFUsM7O7CQak24HL3T0BYGZXAIuAKHCbuy/LYXzA7jEJtSRERLrLWZJw91bg/Vm23QzcnKF8IbAwVzFlkmpJKEeIiHRX8mdchw0JkupuEhHppuSTRMcUWCUJEZFuSj5JmGY3iYhkVfJJQi0JEZHsSj5JdIxJ6IxrEZFulCRS3U1qSYiIdFPySWL32k1KEiIiXSlJRNSSEBHJpuSThNZuEhHJruSTRKoloYaEiEh3JZ8kUrOb1JIQEelOSUKzm0REsir5JKHZTSIi2SlJaHaTiEhWJZ8kOpYKV0tCRKSbkk8SuuiQiEh2ShIdA9cFDkREZBAq+SQRCY9AQiv8iYh0U/JJojwWBaC1XUlCRKSrkk8S8ahhBi1KEiIi3ZR8kjAz4tEIrQklCRGRrnKWJMzsSDN7wsyeNbMlZnZcWG5m9l0zW2Vmz5vZ0WnPucTMXg5vl+Qqtq7iEaNdI9ciIt3EcrjvrwFfcPc/mtm54eNTgXOAGeHteOBW4HgzGwl8HqgDHFhqZgvcfVsOYwQgFo3QrpaEiEg3uexucmB4eH8EsD68fx5whweeAKrNbAJwNvCAu28NE8MDwNwcxtchHjXadJ6EiEg3uWxJ/BewyMy+QZCM3hKWTwTq0+qtDcuyledcPBqhTQPXIiLd9CtJmNmDwPgMm64HzgCudvffmdl7gZ8AcwDLUN97KM/0uvOAeQC1tbV9iLyzWNRoV0tCRKSbfiUJd5+TbZuZ3QFcFT78DfDj8P5aYHJa1UkEXVFrCcYs0ssfyfK684H5AHV1df3+dI9HIrRpTEJEpJtcjkmsB04J758OvBzeXwBcHM5ymg00uPsGYBFwlpnVmFkNcFZYlnPxqJKEiEgmuRyT+BDwHTOLAc2E3UPAQuBcYBXQCFwG4O5bzexGYHFY74vuvjWH8XWIRTUFVkQkk5wlCXf/K3BMhnIHLs/ynNuA23IVUzaxaESzm0REMij5M64ByqKm8yRERDJQkgBiGrgWEclISYJgTKJNYxIiIt0oSRDMbmrX9SRERLpRkiBclqNdLQkRka6UJEjNblJLQkSkKyUJtFS4iEg2ShLojGsRkWyUJAi7m9SSEBHpRkmCYOBas5tERLpTkiCcAquWhIhIN0oSBCfTtWpMQkSkGyUJgutJaO0mEZHulCQIWhJJh4RWghUR6URJgmBMAtA0WBGRLpQkCGY3AbrOtYhIF0oSBEuFAxqXEBHpQkkCiMeCw6AZTiIinSlJEKzdBOhcCRGRLpQkCJblACUJEZGulCTYPXCt5cJFRDpTkkBTYEVEsulXkjCz95jZMjNLmlldl23XmdkqM1tpZmenlc8Ny1aZ2bVp5VPN7Ekze9nMfm1mZf2JrTdiGpMQEcmovy2JF4F3AY+lF5rZTOBC4FBgLvB9M4uaWRS4BTgHmAm8L6wL8FXgW+4+A9gGfLCfse01tSRERDLrV5Jw9+XuvjLDpvOAu9y9xd1fA1YBx4W3Ve7+qru3AncB55mZAacDvw2f/zPgnf2JrTd2Jwm1JERE0uVqTGIiUJ/2eG1Ylq18FLDd3du7lGdkZvPMbImZLdm8eXO/g42mups0cC0i0klsTxXM7EFgfIZN17v7H7I9LUOZkzkpeQ/1M3L3+cB8gLq6un5//Y+Fs5uUI0REOttjknD3OX3Y71pgctrjScD68H6m8i1AtZnFwtZEev2ci5haEiIimeSqu2kBcKGZlZvZVGAG8BSwGJgRzmQqIxjcXuDuDjwMXBA+/xIgWytlwKW6m5KuMQkRkXT9nQJ7vpmtBU4A7jOzRQDuvgy4G3gJuB+43N0TYSvhCmARsBy4O6wL8Cng42a2imCM4if9ia03omFLQpObREQ622N3U0/c/R7gnizbbgZuzlC+EFiYofxVgtlPeZdqSeiiQyIinemMa5QkRESyUZIAwtMkSGhMQkSkEyUJds9uSqolISLSiZIEaVemU5IQEelESQIIc4RaEiIiXShJkDZwrTEJEZFOlCTQ7CYRkWyUJEg/mU5JQkQknZIEGrgWEclGSQKoKAsOQ3NbosCRiIgMLkoSQFk0QjRi7Gppz7jd92JAO5l0GhrbWL1lF9sbWzvKBkIy6XsVg4jIQOvX2k37CjOjqizK9x95he8/8goHjBnCnR+azcuv7+RTv3ueddubeOK6MzCDVzfv4oV121m7rYkVG3awtbGVbbta2d7UlnFM4+bzD6OpNcFN9y0H4Nv/eiTHTR3JPc+s4+uLOl/Ub+roITS3JThm/xq27mrljZ2tvLGrlS07WwA4cfoo6rc20djazjH71/CRUw5g7bYmPnbXM1w950CuOG06kYhx7/PrueLOZwA4YMwQXtm8i9qRVTQ0tXHAmCFMqK6kMh7lt0vXdnr9/UdV0Z5wrpl7ENGIdezj8WtPZ2J1JTtb2vnen1/mitOnM6wiTmNrO6u3NPKnlzay34hKtje1svCFjRwyYTiPrtzEW2dNwB0amtr48CnTqB05hLJYhNb2JBsamkgknWljhrJk9Vau/NUzbGhoBmC/ERUcMHYoq9/YRf3Wpm7HdGJ1Jeu2B+U1VXG2NbZx17zZrN6yiz+v2MRVZ8xg5oThRCJG/dZGTvrawx3PLYtGaE0kGT+8guGVMTZsb2ZHSztDyqLsat3dkjxycjWzJo3gshOnArBsfQNtiSTnHDaBiniUR/+xmUtuewqAv1xzGtHwtYaUx5g8sooRlfG9ffv1KJF0XtuykxfXvckbu1oZVhFjy84WJtVUsbO5nR3NbYwaWk5jaztvOWA0E6srqSyL9rjPzTta+MfrO/ja/SvYsrOVy0+bzkHjh7F5RwsbGpoYXhGnsixKS3uClrYkrYkkx08dRTQCja0JZk2qZmNDMxXxCNVVwaXo73xyDZ++5wWWfeFshpRn/1hxd/7lqw+zbnsTx00ZSVsySdLhqjOmc8K00fzj9R1sa2xl5oThjB1ewZvNbbz/x0/y3rrJvH/2/h372N7YhhkkHSIGO5rbeXnTDlraklRXlbFsfQOnHzyWaWOGdrx2Muk4uyequDtv7Grl8VVb2LKzlXHDyxlaHmPVpp0Mr4izs6WdpDsRM15/s5mjaqvZ2ZKgIh7hnMMmdOxnoDS3JaiIR/dYlm9W7N9Q6+rqfMmSJf3ez5Rr7+tV/bJYhOljhjJldBU1VWXBbUgZO5rbWPNGI79/Zl3fYxlVxeih5YwcUsaooeWs395EZTzKph3NPL1me9bnfe2CWby6eRc/ePSVjrLRQ8sZURmjpqqMDQ3NjKiM09yeoLElwcY3mzvq1e1fw5J/bsu43wkjKjh5xhh+vaQ+4/b+OHPmOB546fVu5dGI9WsiwbmHj+eY/Udy470v9VhveEWMiTVVvP5mM63tSXa2tFMZj9LUQ9fjEZOrea4++99hWHmMJZ+dQ3ms7//ciaRz95J6vrFoJW/sau3184+bMpKnVm/tePynq0/mM/e82Kmsrw4eP4wVG3cA8IV3HMrooeVcfufTAFwz9yD+/cSplMcimO3+EHV3Eknnyde2ctGPn9yr1/nwydP44WOv9jve4RUxpo4Z2vE3W/ixk4hFjbO+9Vi/933AmCEkHY6qreb8oyZy0owxrHmjkZO//vCen5zFnEPGUb+1kZWvB8f4of8+hWljhtKeSDL9+j8C8LdrTyfpzqSaqj6/jpktdfe6PdZTkgic8OU/s6GhmffPruUXT6wB4PpzD+H8oydSd9ODHfW++d4jOP3gsYyojHf6J8ikfmsjL6xrYNakEZgZJ37loY5tR0yupnZkFV9+1+EMDb95NbUmaGpLMHJIWdZ9bmxo5muLVvDMmu2ccuAYjt6/hvueX8+iZZ0/aG+96GhOPnBMj9/qWtuTlMV29zgmks6S1Vv59ZJ6fv/0Og4aN6zjjQpBS+bxVW902sfooeVUxCPMnjaKRNKpm1LD9DFDWd/QxH4jKjEznl+7nZsXLifbW60sGuGTZx/E24/Yj3HDy/d4XFPcnQXPreequ57dY93HPnka+1VXEIvuXQ/r4tVbeW3LLlZv2cXkkVX8+C+v8srmXZ3qzDlkLA8u3wTADW+fybQxQ/njixv51VNreO5zZzGiqm+tiWTS+Y87lvDQik0cNnE4F58whUk1lQyviDOkPMbWXa2MqAz+ro2tCYZXxKnf1sivF9fzzJrtHa2svfW2WRO44JhJjB5aTnvSiRiUx6KUxyKUxyM89drWTse46/sCYMywcjbvaOlUNqIyTlsiSXvCaU1bh7+qLMpj15zG0PIY8WiEpf/cxh1/X829z2/oVdwTRlRw6H7DqYhHOXH6aLY3trFlZwuzJo3gtsdXZ03kY4aVA3SL96Ljazlw3DAeWrGJ6qo467Y1UVUeo6UtwRu7Wjlz5jgamtq488k1WWP65nuP4ON3P5dx21G11TyzZjsTqytpTyapqSpjxcYdHDx+GPVbGzu1ZEdUxmloaut4fOyUGhav7v4l7v7/OomDxw/PfpB6oCTRS2veaKSqPMrooeU0NLVRVRYlvpcfKHvrufrtPL+ugQuPnTyg+25uS/Dfdz/HuOEVvH92bacmdn898eobLH5tK2ceOo6Dxw+nuS1BWTRCpA9N7abWBJFI8AG0q6WdT/zmOQ6ZMJzLT5ve56a7u7N2WxPL1jdw9qHjMTO+8H/L+Pnf/8nHzzqQD598wIB0C7g753znLx3foG8+/zAuOn7/bvXu+PtqPveHZSz5zBxGDy3vcZ/JpPNM/TauuPMZDhw3jO++7ygq41E++LPF/OXlLXzy7IP4z1MP2OukmbKjuY14NEJFPMrDKzZx2e2LAfjppccSj0Y4Zv+aPXZJZYu3uT1BVVmQoL60cDkPLn+dy06cynvrJnHQZ+7vqHvSjNEcMGYosYgRj0WIR4x4NEIsGuGo2mpmTxuV9XU2NjTz2T+8yJGTq/nIKQewYuObXH/Pi/z2IyfsdZJPPxavv9nM9LHD2NjQzKnfeJjmtiQTqyu55aKjOXJyda+PA8Afnl3HVXc92+3DHGDyyEo+97ZDOXPmuF7ts7G1nZfWv8kRk6uJRyO0tCc6HdOu3nLAKH58SV3H36O3lCREcuDZ+u1UxCNZv72l+uaf/PQZjBtekbHOjuY2vnr/Ch5avon1Dc2dtk2qqWTttqAl8NqXz+11guiqLZHk14vrmXvY+D0mrVLwt1VbeGXzTt519KQeW9l7Y0NDE2OHVRCNGC+ua+DSny7mqNpqvvruWT32BvTWxbc9xWP/2MyFx07mK++eNWD7VZIQKYC7F9dzze+e7xjsz+TyO5/mvuc3MG3MED500jSqyqId3TmzJo3g8tOmc8bBY3v9rVmkN/Y2SWh2k8gASnVt7Wxup35rI5t2tLBlZ0vHDLhNb7Zw3/MbeP/sWm565+Edzztqcg0t7QlmjBtWqNBFMlKSEBlAsWiQJM7+duaZM2XRCBOrK/nXutpO5bWj+j5LRSSXlCREBtB+YRfTCdNG8a6jJzJmWDmjh5ZTM6SMmqo4lfFov8cZRPJJSUJkAB07ZSQrb5rbr3MkRAaTfo2Mmdl7zGyZmSXNrC6t/EwzW2pmL4Q/T0/bdkxYvsrMvmvh1yozG2lmD5jZy+HPmv7EJlIoShCyL+nv9IkXgXcBXTtgtwBvd/fDgUuAn6dtuxWYB8wIb3PD8muBP7v7DODP4WMRESmgfiUJd1/u7iszlD/j7uvDh8uACjMrN7MJwHB3/7sHc2/vAN4Z1jsP+Fl4/2dp5SIiUiD5mIj9buAZd28BJgLpq8qtDcsAxrn7BoDw59g8xCYiIj3Y48C1mT0IjM+w6Xp3/8Mennso8FXgrFRRhmq9PpvPzOYRdFlRW1u7h9oiItJXe0wS7j6nLzs2s0nAPcDF7p5alnQtMCmt2iQg1S31uplNcPcNYbfUph5img/Mh+CM677EJyIie5aT7iYzqwbuA65z98dT5WE30g4zmx3OaroYSLVGFhAMchP+7LGVIiIiudevtZvM7Hzge8AYYDvwrLufbWafAa4DXk6rfpa7bwqnyt4OVAJ/BK50dzezUcDdQC2wBniPu+9x8Xsz2wz8s8+/RGejCWZmFRPFnB+KOT8Uc36MBoa4+5g9VSz6Bf4Gkpkt2ZsFrwYTxZwfijk/FHN+9CZmLTMpIiJZKUmIiEhWShKdzS90AH2gmPNDMeeHYs6PvY5ZYxIiIpKVWhIiIpKVkkQRSK2UK7ml4yyZlPr7ouSSRLgkeSS8XxR/fFefYF4U23E2s2mFjqG3zOxDZrZfoePojWJ7Xwy0kkkSZvZvZvYs8C2C9aQG/R/fzC41s4fN7ItmNrvQ8ewNM5tnZleF94siCZvZRWb2kJndaGZz9/yMwjKz95nZMuDtRXSMLwz//z4LHFboePaGmV1iZveb2TVmdmyh49kb4f/fjWZWOVD7LIkkYWZnAJcDVwI3Acea2YzCRtWzMCn8F3ADsAP4bzM7K9w26P5uZlZhZtcDnwduMLMpgzkJW6DazH5GsAzMTUALcIGZjS5sdN2F8Q41sx8RrGYwz92/kzrGgzFZmFnEzMaa2UPAvwFXAU8SLvQ5GN/HKWb2DuA/gC8RrCN3Vfg5MijjNrOYmX0U+DTwHmDATu4bdL/sQOnyhzwS+D93/wtQTrDQYNYFBAvFzNIXXJwB/N7dHwVuIVjL6vMA7p4sQHgZmVkUwN2bgSXuPhH4EcGH7qBkZlEPbAd+7u5nuftDwEvATncfVEsspMW7E2gFfuruj4dJY3Zqe6HjTBfGlHT3TcD/c/d3hO/llcBlMLjex7D7vRw6F7jD3R8Dfg+0AZ+CwRc3gLu3A08DBwM/BC4Llzrqt30ySZjZp4Gvm9m7w6LngbPN7E5gIVAD/NLMPhfWL/hxMLPrgB+a2YVh0evA+wHcvRH4FbDFzK4M6xf8m6OZ3QB8N+04PxD+/AJwvJmdFtYr+PFN6Rqzuz8Yfku/DPgf4MiwuT4oWm1p8b4nLLoVOMbMfgn8neCb44/M7LywfsGPdVrMFwC4+33hMY4CS4BNFiwCOmh0jZngapsfAnD3N4HNwHALLlMwWP7/rjCzw9OKng2/rN1KsML2nIF4PxT8DTWQzGyWmT1J0Oe5GPicmb3N3R8gaIK9DvyHu78V+ARBF87oQn4zMLOjw77aQ4H/JeiqmePufwLWmdnHwqpJ4AdAnZlVFPqbY/hPdRxBYrjSzK4GqgHcfRfwXeALZmaD5ZtXppjNbFR4LNcAs4CzgeXAx8xsSIHfG+nxXmFmHwdWAH8DmoBTgQ8ADwOXFjpeyBjz1WY2MmwJJQi69I4IW3GDQpb38gKCZHanmT0NtAPfBqaaWaSQ/39mtr+ZPQp8BvhmqtzdW8LYmoGfEnTxTen3C7r7PnMj6Faal/b4euD28P4Igmbj2LTtdxK8YQsZ8wTg3LTHPwLOD++fBrxCsFojwBnAt8P7VsCY48CDwCHh41OArwOXd6n3OME10GuBtxb4OGeL+coMdU8AfgwMLdRxzhLvN4F/Dx9XpNU9MYy3qkjeF8uB0wv5ftiL43xR+Pgg4MTw/oeAG8P7hTzOwwguujYMWARcGpZHu9T7OUHX3rGp36cvt6JtSWRp7r0M/CKtifUokDSzuLs3AI3Aj83sIDP7NsEH9Gv5iThzzO6+wd0XmlmZmf2c4Nre/2Zm57n7wwTdY7dbMJB9IcHL4jxEAAAJTklEQVQbAw/fBfmOOfym0kbwj/6+sPhvBC23w83swLTq3wB+S9B0r8pDuKkYexPzoV1iBrgUaHf3nfk4zr2I9wngODM70INviykXA23u3jjY3xdmVk7wwZb3yQG9PM4nm9lB7r7Sg/EfA/4FeBUK+v9n7r6DYCxtB0HvwhXhZ1wi7NZLff7dAXyf4MtxRV9jKNokkS51IN19V/iPkmpynwNsDN8IEHwTWEnQFQLBt9s38xttZu7eCvwVGEfwrXCOmb0N+DhwP8GgWQK4Is+hDYVOA9SpY3svUGtmB4fH9wXgTWC/sP4xBNMdfwjMdPffFEHMn7JgamkTcHURxHuFmb0YxvvxPMbb55g9uNb9fkBDnuOF3sXcQHjZZguum/MUweD1Lwscs4c/m8LtfwD+QTAOiAeSZnYAweSRXwAHuftP+hxBoZpM/WhqzQ0PzE1AXVp5hN1rUcXCn78B3hLePxyoCu8PGWwxZ3jOHcCH0x6X5zFeA8YCjwC/7rItGv6cDHwR+HLatnuBd6dtn1wkMV8Q3j+dsNuhSOI9GTi4SI7xu9MeVxZJzKnjfAgwZZDEbF0/M4BjgKUEvQzTCb5oVgITBiKeomhJhE2oCjO7nWCw5icEGfaDZjYqNTjq7h7OmoiHT90JTDazXwA3srurZtdgi9nSpt9ZME9/JMFUXcKYW3Idc9prOdAc3maZ2TlhXHEPBh8hOHdjEUF3zccsmG4XA3aF+6h39/oii/khd19eRPE+5u4r8hHvAMS8M20/TeTJQMTs7svdffUgidnTPjPiYf2lwHPAVuBnBEm4yYPLRQ9IQEVzA85nd/Y/GfhBlwx7S3iQxgHTCGYEPQNcVQQxTyNo3n4HeBa4poAxR4CZwFeA84C/p22LE/Rz3kbQr3wswUyKF4AbFPO+Ga9iHlQxpz4zpoRlVwP1wCdzEk+hDsReHqyPhQfqvV3K30Mwb/lhghbCWwimsN0O1IR1xhLMIR9ZRDGPJJi1UKiY07sEqgkGvEaHPz8CHEBwJmdHzGHdKGmzbRRz8cermIsq5jNy+ZmRtwPRy4NmBNnxceACgtkHlxJOXyWYH344QZPwPwkGescVc8wUYEpdDzGPDN+MnwvrfYKgi+P/ujw/qpj3rXgVc1HFHMtHnOnLQAwa7u4WnK37GXd/2Mx2Epzk5MDP3P2RVF0zewE4CdgVznIqyMlb+1DMcwlmyzwOnGJmC4H9w8evhvGnYk5k2bViLtJ4FXNRxdyejzgLPnCdae5yeHcJwQcp7n4/wTSvQ6z7nPazCA5qkwdy/mG7j8e8kuDM4yMJ+jkXu/uhBOdonGpmExXzvhGvYlbMe6PgSYJgqlaHtF9+FTDMdq9N8ijBWdPDLTjx7ANm9jxBlr02z98E9uWYHwOGE4yffMTdPx/W30pw5um6PMULxRdzscULijlfijFmoIBJwoLVK38H3GJmZ6WmgNrulVCfIjh57Ewzi7n7S8BE4BgPTjyrBz7q7hd7sNKkYh6YmJcRJLGj3L3ZzKKpb0EerEKqmIs8XsWsmHujIEnCzE5l9+niKwlWO62x4DT5dgB3X0VwSv904NrwqS3AP8Ptj7j744o5ZzGvDrcn3INRMsVc/PEqZsXcW4VqScwi6Gv7JcFp43GCdfyTAGZ2k5n9hOAswu8SrFezlOBkkT8pZsU8iGIutngVs2LuHc/PVK/ZwIFpj48kOBCfJ1i++xGCE1r+leD8gTuB6Wn1hwLV+YhVMSvmfSlexayY+/175figVQP3EZz2/hlgaNq248IDllrr54MEy2QfkVYnkvcDopgV8z4Qr2JWzAN1y3V30xCCNVGuDO+flNrg7k8BYwj764GHwoO9DTqW8S3EBVQUc34UW8zFFi8o5nwpxpj32oAnCTO72MxOMbPhHkzXmg/cTbBY1fFmllrmuJxg7fb/DJ96BsGZhs2Q3+vIKmbFvC/Eq5gVcy6kltbu306CKVrjCfrYkoRXUyNYWG9LWOdE4L3AEnf/eVh2KEF/3XiCtdqv8DytwqmYFfO+EK9iVsw5NwD9cakVTg8EfhHejwHfA37fpe7VBNdUqCZcU57gJJNp+exjU8yKeV+IVzEr5nzc+tzdZGYxM/sS8CUzO4XgWrAJAA/mAH8MOCHclvIjghH8B4DVFpxi3uTur/Y1DsWsmEstXsWsmPOpT0kiPCBLgRqC08pvJGhGnWZmx0HHhTO+CNyQ9tS3EvTNPQsc7nk8xVwxK+Z9IV7FrJjzro9Nr5OAD6Q9/j7wUYJlbpeGZRGCPri72X1xjPOAkwvRZFLMinlfiFcxK+a8H4c+HrwqoJzd/XQXEV4fliB7XhnerwN+VehfUjEr5n0lXsWsmPN961N3k7s3unuL717F9EyCVQsBLiNYHvte4FfA09B9qdx8U8z5UWwxF1u8oJjzpRhjzoV+XXTIghUNneCa0gvC4h0Elw09DHjNw/44D1NuoSnm/Ci2mIstXlDM+VKMMQ+k/p5MlyRYtGoLMCvMqp8Fku7+Vx+cAzaKOT+KLeZiixcUc74UY8wDp7/9VQSLWiWBvwIfLHT/mWIePLdii7nY4lXMijkft36fcW1mk4APAN9095Z+7SxPFHN+FFvMxRYvKOZ8KcaYB8qALMshIiL7psFwjWsRERmklCRERCQrJQkREclKSUJERLJSkhARkayUJET6wcxuMLNP9LD9nWY2M58xiQwkJQmR3HonoCQhRUvnSYj0kpldD1wM1BMs+LYUaADmAWUE1x74AHAkcG+4rQF4d7iLW4AxQCPwIXdfkc/4RXpDSUKkF8zsGOB24HiCBTKfBn4A/NTd3wjr3AS87u7fM7PbgXvd/bfhtj8DH3H3l83seIKlp0/P/28isnf6tQqsSAk6CbjH3RsBzCy1KuhhYXKoJrh05aKuTzSzocBbgN+krShdnvOIRfpBSUKk9zI1v28H3unuz5nZpcCpGepEgO3ufmTuQhMZWBq4Fumdx4DzzazSzIYBbw/LhwEbzCxOcAWzlB3hNtz9TeA1M3sPBBeoMbMj8he6SO9pTEKkl9IGrv8JrAVeAnYB14RlLwDD3P1SMzsR+BHQAlxAsNz0rcAEgmsU3OXuX8z7LyGyl5QkREQkK3U3iYhIVkoSIiKSlZKEiIhkpSQhIiJZKUmIiEhWShIiIpKVkoSIiGSlJCEiIln9fxhoMTjOLs2FAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "deleted = re.compile('Deleted media Notice.+')\n",
    "full = re.compile('.+is full.+')\n",
    "\n",
    "def parse_medialog(row):\n",
    "    res = 0\n",
    "    if re.match(deleted,row.log): res = -1\n",
    "    elif re.match(full,row.log): res = 1\n",
    "    return res\n",
    "\n",
    "\n",
    "filter = ((log.program=='nsrd') & (log.log.str.contains(\"[Mm]edia Notice\")))\n",
    "(log[filter].apply(parse_medialog,axis=1).cumsum()).plot() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f1b02ff4668>"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "daterange = (log.index > '03/28/18') & (log.index < '04/11/18')\n",
    "filter = (daterange & (log.program=='nsrd') & (log.log.str.contains(\"[Mm]edia Notice\")))\n",
    "(log[filter].apply(parse_medialog,axis=1).cumsum()+3100).plot() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}