subcommand_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "# coding=utf-8\n",
    "\"\"\"A simple example demonstrating how to use Argparse to support subcommands.\n",
    "This example shows an easy way for a single command to have many subcommands, each of which takes different arguments\n",
    "and provides separate contextual help.\n",
    "\"\"\"\n",
    "import argparse\n",
    "import cmd2\n",
    "import newspaper as np\n",
    "from dateutil.parser import parse\n",
    "from roundup_db1 import Entry, Category, Keyword, Publication, Author, Section, DataAccessLayer\n",
    "import app\n",
    "import sys, glob, datetime, os\n",
    "import BTCInput2 as btc\n",
    "import itertools as it\n",
    "import warnings, functools, pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_StoreAction(option_strings=['-sec', '--use_sections'], dest='use_sections', nargs=None, const=None, default=None, type=None, choices=None, help='enter \"yes to use the sections\"', metavar=None)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "###SEARCH COMMAND\n",
    "\n",
    "# create the top-level parser for the search command\n",
    "search_parser = argparse.ArgumentParser()\n",
    "search_subparsers = search_parser.add_subparsers(title='subcommands', help='subcommand help')\n",
    "\n",
    "# create the parser for the \"entry\" subcommand\n",
    "parser_entry = search_subparsers.add_parser('entry', help='entry help')\n",
    "parser_entry.add_argument('-id', '--entry_id', help='id of the entry')\n",
    "parser_entry.add_argument('-idr', '--id_range', nargs=2,\n",
    "                              help='minimum and maximum ids', )\n",
    "parser_entry.add_argument('-d', '--date', help='date of entry')\n",
    "parser_entry.add_argument('-l', '--url', help='article_url')\n",
    "parser_entry.add_argument('-t', '--title', nargs='*', help='entry name')\n",
    "parser_entry.add_argument('-dr', '--date_range', nargs=2, help='start date, end date')\n",
    "parser_entry.add_argument('-c', '--category_id', help='category id')\n",
    "parser_entry.add_argument('-desc',  '--description', nargs='*',\n",
    "                           help='article description (optional)')\n",
    "\n",
    "#create the parser for the \"category\" subcommand\n",
    "parser_category = search_subparsers.add_parser('category', help='category help')\n",
    "parser_category.add_argument('-id', '--category_id', help='category id')\n",
    "parser_category.add_argument('-n', '--category_name', nargs='*', help='category name e.g. Python')\n",
    "parser_category.add_argument('-s', '--section_id', help='section id')\n",
    "\n",
    "#create the parser for the \"keyword\" subcommand\n",
    "\n",
    "parser_keyword = search_subparsers.add_parser('keyword', help='keyword help')\n",
    "parser_keyword.add_argument('-id', '--keyword_id', help='keyword id')\n",
    "parser_keyword.add_argument('-w', '--word', nargs='*', help='keyword text e.g. mapreduce')\n",
    "\n",
    "#create the parser for the \"section\" subcommand\n",
    "parser_section = search_subparsers.add_parser('section', help='section help')\n",
    "parser_section.add_argument('-id', '--section_id', help='section id')\n",
    "parser_section.add_argument('-n', '--name', help='section name')\n",
    "\n",
    "###ADD COMMAND\n",
    "add_parser = argparse.ArgumentParser()\n",
    "add_subparsers = add_parser.add_subparsers(title='subcommands', help='subcommand help')\n",
    "\n",
    "#create the parser for the \"entry\" subcommand\n",
    "\n",
    "parser_add_entry = add_subparsers.add_parser('entry', help='entry help')\n",
    "parser_add_entry.add_argument('-l', '--url', help='url of article')\n",
    "parser_add_entry.add_argument('-c', '--category_id', help='category id e.g. Comoros is 1')\n",
    "parser_add_entry.add_argument('-d','--date', help='article date')\n",
    "parser_add_entry.add_argument('-desc',  '--description', nargs='*',\n",
    "                           help='article description (optional)')\n",
    "\n",
    "#create the parser for the \"category\" subcommand\n",
    "\n",
    "parser_add_cat = add_subparsers.add_parser('category', help='category help')\n",
    "parser_add_cat.add_argument('-n', '--name', nargs='*', help='category name e.g. Python')\n",
    "parser_add_cat.add_argument('-s', '--section_id', help='section id')\n",
    "\n",
    "#create the parser for the \"section\" subcommand\n",
    "parser_add_sec = add_subparsers.add_parser('section', help='section help')\n",
    "parser_add_sec.add_argument('-n', '--name', nargs='*', help='section name')\n",
    "\n",
    "#create the parser for the \"publication\" subcommand\n",
    "parser_add_pub = add_subparsers.add_parser('publication', help='publication help')\n",
    "parser_add_pub.add_argument('-t', '--title', nargs='*', help='publication title')\n",
    "parser_add_pub.add_argument('-l', '--url', help='publication url')\n",
    "\n",
    "##EDIT COMMAND: parsers for editing Entries, Categories, Sections, Keywords,\n",
    "#Publications, and Authors\n",
    "\n",
    "edit_parser = argparse.ArgumentParser() #main parser for the edit command\n",
    "edit_subparsers = edit_parser.add_subparsers(title='subcommands', help='subcommand help')\n",
    "\n",
    "#create the parser for the \"entry\" subcommand\n",
    "edit_entry_parser = edit_subparsers.add_parser('entry', help='entry help')\n",
    "edit_entry_parser.add_argument('-id', '--entry_id', help='the id number of the entry to edit')\n",
    "edit_entry_parser.add_argument('-t', '--edit_type', nargs='*',\n",
    "                            help='edit types: title, date, keywords, description, category_id')\n",
    "\n",
    "#create the parser for the \"category\" subcommand\n",
    "edit_category_parser = edit_subparsers.add_parser('category', help='category help')\n",
    "edit_category_parser.add_argument('-id', '--category_id', help='edit category name')\n",
    "edit_category_parser.add_argument('-nn', '--new_name', nargs='*', help='new name value')\n",
    "\n",
    "#DISPLAY COMMAND: parsers for displaying categories and sections\n",
    "\n",
    "disp_parser = argparse.ArgumentParser()\n",
    "disp_subparsers = disp_parser.add_subparsers(title='subcommands', help='subcommand help')\n",
    "\n",
    "#create the parser for the categories subcommand\n",
    "disp_cat_parser = disp_subparsers.add_parser('categories', help='category help')\n",
    "disp_cat_parser.add_argument('-s', '--section_id', help='section_id')\n",
    "\n",
    "#create the parser for the sections subcommand\n",
    "disp_sec_parser = disp_subparsers.add_parser('sections', help='section help')\n",
    "disp_sec_parser.add_argument('-s', '--section_id', help='section_id')\n",
    "\n",
    "#create the parser for the entry_count subcommand\n",
    "\n",
    "disp_ent_count_parser = disp_subparsers.add_parser('entry_count', help='entry count')\n",
    "disp_ent_count_parser.add_argument('-d','--date_range', nargs=2, help='start date, end_date')\n",
    "\n",
    "#create the parser for the entries_needed subcommand\n",
    "\n",
    "disp_ents_needed_parser = disp_subparsers.add_parser('entries_needed', help='entries needed')\n",
    "disp_ents_needed_parser.add_argument('-d','--date_range', nargs=2, help='start date, end_date')\n",
    "\n",
    "##EXPORT COMMAND: parsers for the commands\n",
    "\n",
    "exp_parser = argparse.ArgumentParser() #different from the exportparser\n",
    "exp_subparsers = exp_parser.add_subparsers(title='subcommands', help='subcommand help')\n",
    "\n",
    "#create the parser for the \"docx\" subcommand\n",
    "\n",
    "docx_parser = exp_subparsers.add_parser('docx', help='docx help')\n",
    "docx_parser.add_argument('-t', '--title', nargs='*', help='roundup title')\n",
    "docx_parser.add_argument('-f',\n",
    "        '--filename', help='filename (same directory as the app)')\n",
    "docx_parser.add_argument('-r', '--date_range', nargs=2,\n",
    "                                 help='search the dates between the start and end dates')\n",
    "\n",
    "#create the parser for the \"html\" subcommand\n",
    "\n",
    "html_parser = exp_subparsers.add_parser('html', help='docx help')\n",
    "html_parser.add_argument('-t', '--title', nargs='*', help='roundup title')\n",
    "html_parser.add_argument('-f',\n",
    "        '--filename', help='filename (same directory as the app)')\n",
    "html_parser.add_argument('-r', '--date_range', nargs=2,\n",
    "                                 help='search the dates between the start and end dates')\n",
    "#create the parser for the jsx subcommand\n",
    "\n",
    "jsx_parser = exp_subparsers.add_parser('jsx', help='docx help')\n",
    "jsx_parser.add_argument('-t', '--title', nargs='*', help='roundup title')\n",
    "jsx_parser.add_argument('-f',\n",
    "        '--filename', help='filename (same directory as the app)')\n",
    "jsx_parser.add_argument('-r', '--date_range', nargs=2,\n",
    "                                 help='search the dates between the start and end dates')\n",
    "\n",
    "#create the parser for the jsx_file subcommand\n",
    "\n",
    "jsx_full_parser = exp_subparsers.add_parser('jsx_file',\n",
    "                                            help='creates a javascript file for the Codigo Ecuador website')\n",
    "jsx_full_parser.add_argument('-t', '--title', nargs='*', help='roundup title')\n",
    "jsx_full_parser.add_argument('-f',\n",
    "        '--filename', help='filename (same directory as the app)')\n",
    "jsx_full_parser.add_argument('-r', '--date_range', nargs=2,\n",
    "                                 help='search the dates between the start and end dates')\n",
    "jsx_full_parser.add_argument('-sec', '--use_sections', help='enter \"yes to use the sections\"')\n",
    "\n",
    "#DELETE: parsers for the delete command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RoundupCMD(cmd2.Cmd):\n",
    "    \"\"\"\n",
    "    Example cmd2 application where we a base command which has a couple subcommands\n",
    "    and the \"sport\" subcommand has tab completion enabled.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    #add item section\n",
    "    \n",
    "    def base_ent(self, args):\n",
    "        '''Adds an article with a single type entry on the command line'''\n",
    "        if not args.description:\n",
    "            app.add_entry(session=a.d.session, url=args.url, category_id=args.category_id, date=args.date)\n",
    "        else:\n",
    "            app.add_entry(session=a.d.session, url=args.url, category_id=args.category_id,\n",
    "                   date=args.date, description=' '.join(args.description))\n",
    "            \n",
    "    def base_cat(self, args):\n",
    "        '''Adds a category with a single entry on the command line'''\n",
    "        app.add_pub_or_cat(new_name=' '.join(args.name),\n",
    "                           second_item=args.section_id,\n",
    "                          session=a.d.session, add_type='category')\n",
    "        \n",
    "    def base_sect(self, args):\n",
    "        '''Adds a new section to the roundup'''\n",
    "        warnings.warn('add_section not yet tested')\n",
    "        app.add_item(session=a.d.session, search_type='section',\n",
    "                     new_name=' '.join(args.section_name))\n",
    "        \n",
    "    def base_pub(self, args):\n",
    "        '''Adds a publication to the database'''\n",
    "        warnings.warn('add publication not yet tested')\n",
    "        app.add_pub_or_cat(new_name=' '.join(args.title),\n",
    "                           second_item=args.section_id,\n",
    "                          session=a.d.session, add_type='publication')\n",
    "        \n",
    "    parser_add_entry.set_defaults(func=base_ent)\n",
    "    parser_add_cat.set_defaults(func=base_cat)\n",
    "    parser_add_sec.set_defaults(func=base_sect)\n",
    "    parser_add_pub.set_defaults(func=base_pub)\n",
    "    \n",
    "    @cmd2.with_argparser(add_parser)\n",
    "    def do_add(self, args):\n",
    "        \"\"\"Search command help\"\"\"\n",
    "        func = getattr(args, 'func', None)\n",
    "        if func is not None:\n",
    "            # Call whatever subcommand function was selected\n",
    "            func(self, args)\n",
    "        else:\n",
    "            # No subcommand was provided, so call help\n",
    "            self.do_help('search')\n",
    "    \n",
    "    #search section\n",
    "    \n",
    "    def base_category(self, args):\n",
    "        '''Generic category search function'''\n",
    "        app.find_category(session=a.d.session, args=args)\n",
    "        \n",
    "    def base_entry(self, args):\n",
    "        '''Generic entry search function'''\n",
    "        app.find_entry(session=a.d.session, args=args)\n",
    "    \n",
    "    def base_section(self, args):\n",
    "        '''Generic section search function'''\n",
    "        app.find_section(session=a.d.session, args=args)\n",
    "        \n",
    "    def base_keyword(self, args):\n",
    "        '''Generic keyword search function'''\n",
    "        app.find_keyword(session=a.d.session, args=args)\n",
    "        \n",
    "    parser_category.set_defaults(func=base_category)\n",
    "    parser_section.set_defaults(func=base_section)\n",
    "    parser_entry.set_defaults(func=base_entry)\n",
    "    parser_keyword.set_defaults(func=base_keyword)\n",
    "\n",
    "    @cmd2.with_argparser(search_parser)\n",
    "    def do_search(self, args):\n",
    "        \"\"\"Search command help\"\"\"\n",
    "        func = getattr(args, 'func', None)\n",
    "        if func is not None:\n",
    "            # Call whatever subcommand function was selected\n",
    "            func(self, args)\n",
    "        else:\n",
    "            # No subcommand was provided, so call help\n",
    "            self.do_help('search')\n",
    "    \n",
    "    #edit section\n",
    "    \n",
    "    def base_edit_entry(self, args):\n",
    "        '''Generic edit entry function'''\n",
    "        edit_types = {'all': app.edit_entry, 'description': app.desc_from_input,\n",
    "                      'category_id': app.cat_id_from_input, 'add keyword': app.add_keyword_to_article,\n",
    "                    'title': app.name_from_input, 'date': app.date_from_input,\n",
    "                     'delete keyword': app.delete_entry_keyword}\n",
    "        if not args.entry_id:\n",
    "            raise Exception('Must enter entry id')\n",
    "        if args.entry_id:\n",
    "            if not args.edit_type:\n",
    "                app.edit_entry(session=a.d.session, entry_id=args.entry_id)\n",
    "            else:\n",
    "                edit_type = ' '.join(args.edit_type).lower() #make into a string with spaces\n",
    "                edit_types[edit_type](session=a.d.session, entry_id=args.entry_id)\n",
    "                \n",
    "    def base_edit_cat(self, args):\n",
    "        '''Generic edit category function'''\n",
    "        if args.new_name:\n",
    "            app.edit_name(session=a.d.session, model='category',\n",
    "                         id_value=args.category_id, new_name=' '.join(args.new_name))\n",
    "        else:\n",
    "            new_name = btc.read_text('Enter new category name or \".\" to cancel: ')\n",
    "            if new_name != \".\":\n",
    "                app.edit_name(session=a.d.session, model='category',\n",
    "                         id_value=args.category_id, new_name=new_name)\n",
    "            else:\n",
    "                print('edit cancelled')\n",
    "                return\n",
    "            \n",
    "    edit_category_parser.set_defaults(func=base_edit_cat)\n",
    "    edit_entry_parser.set_defaults(func=base_edit_entry)\n",
    "    \n",
    "    @cmd2.with_argparser(edit_parser)\n",
    "    def do_edit(self, args):\n",
    "        \"\"\"Edit command help\"\"\"\n",
    "        func = getattr(args, 'func', None)\n",
    "        if func is not None:\n",
    "            # Call whatever subcommand function was selected\n",
    "            func(self, args)\n",
    "        else:\n",
    "            # No subcommand was provided, so call help\n",
    "            self.do_help('edit')\n",
    "    \n",
    "    #export section \n",
    "    #create export function with html and docx as subcommands\n",
    "    #jsx function not yet complete\n",
    "    \n",
    "    def base_docx(self, args):\n",
    "        '''Generic export html function'''\n",
    "        app.create_docx_roundup(args)\n",
    "    \n",
    "    def base_html(self, args):\n",
    "        '''Generic export html function'''\n",
    "        app.export_html2(session=a.d.session, program=args.filename,\n",
    "                        start_date=parse(args.date_range[0]).date(),\n",
    "                         end_date=parse(args.date_range[1]).date(),\n",
    "                        title=' '.join(args.title))\n",
    "        \n",
    "    def base_jsx(self, args):\n",
    "        '''Generic export jsx function for react'''\n",
    "        #print(args)\n",
    "        app.export_jsx(session=a.d.session, program=args.filename,\n",
    "                        start_date=parse(args.date_range[0]).date(),\n",
    "                         end_date=parse(args.date_range[1]).date(),\n",
    "                        title=' '.join(args.title))\n",
    "    \n",
    "    def base_full_jsx_file(self, args):\n",
    "        '''Generic export jsx function for react'''\n",
    "        print(args)\n",
    "        #if hasattr(args, 'use_sections'):\n",
    "        if args.use_sections == None:\n",
    "            app.exp_full_jsx(session=a.d.session, program=args.filename,\n",
    "                            start_date=parse(args.date_range[0]).date(),\n",
    "                             end_date=parse(args.date_range[1]).date(),\n",
    "                            title=' '.join(args.title), use_sections=False)\n",
    "            \n",
    "        elif args.use_sections.lower() == 'yes':\n",
    "            app.exp_full_jsx(session=a.d.session, program=args.filename,\n",
    "                            start_date=parse(args.date_range[0]).date(),\n",
    "                             end_date=parse(args.date_range[1]).date(),\n",
    "                            title=' '.join(args.title), use_sections=True)\n",
    "        else:\n",
    "            raise Exception('use_sections only accepts \"yes\" as an argument')\n",
    "   \n",
    "    docx_parser.set_defaults(func=base_docx)\n",
    "    html_parser.set_defaults(func=base_html)\n",
    "    jsx_parser.set_defaults(func=base_jsx)\n",
    "    jsx_full_parser.set_defaults(func=base_full_jsx_file)\n",
    "    \n",
    "    @cmd2.with_argparser(exp_parser)\n",
    "    def do_export(self, args):\n",
    "        \"\"\"Search command help\"\"\"\n",
    "        func = getattr(args, 'func', None)\n",
    "        if func is not None:\n",
    "            # Call whatever subcommand function was selected\n",
    "            func(self, args)\n",
    "        else:\n",
    "            # No subcommand was provided, so call help\n",
    "            self.do_help('exp')\n",
    "            \n",
    "    #create universal add entry functionality\n",
    "            \n",
    "    finalize_parser = argparse.ArgumentParser()\n",
    "    finalize_parser.add_argument('-d', '--date', help='search a single date')\n",
    "    finalize_parser.add_argument('-r', '--date_range', nargs=2,\n",
    "                                 help='search the dates between the start and end dates')\n",
    "    \n",
    "    \n",
    "    @cmd2.with_argparser(finalize_parser)\n",
    "    def do_finalize(self, args):\n",
    "        '''searches for articles without descriptions and lets user edit them'''\n",
    "        if args.date:\n",
    "            app.finalize(session=a.d.session, start_date =args.date, end_date=args.date)\n",
    "        elif args.date_range:\n",
    "            app.finalize(session=a.d.session, start_date = args.date_range[0],\n",
    "                          end_date=args.date_range[1])\n",
    "        else:\n",
    "            print('Please enter date or date range. Check help for details')\n",
    "            return\n",
    "    \n",
    "    #display section\n",
    "    \n",
    "    def base_entries_needed(self, args):\n",
    "        '''Displays how many articles you need to get five per category'''\n",
    "        app.articles_needed(start_date=args.date_range[0],\n",
    "                            end_date=args.date_range[1],\n",
    "                            session=a.d.session)\n",
    "    \n",
    "    def base_entry_count(self, args):\n",
    "        '''Displays a count of articles in each category between the specified dates'''\n",
    "        app.date_range_count(session=a.d.session,\n",
    "                             start_date = args.date_range[0],\n",
    "                            end_date = args.date_range[1])\n",
    "    \n",
    "    def base_display_sects(self, args):\n",
    "        '''Generic display categories function'''\n",
    "        app.display_sections()\n",
    "    \n",
    "    def base_display_cats(self, args):\n",
    "        '''Generic display categories function'''\n",
    "        try:\n",
    "            if args.section_id.isnumeric() == True:\n",
    "                app.display_categories(section_id=args.section_id)\n",
    "        except AttributeError:\n",
    "            app.display_categories()\n",
    "    \n",
    "    disp_cat_parser.set_defaults(func=base_display_cats)\n",
    "    disp_sec_parser.set_defaults(func=base_display_sects)\n",
    "    disp_ent_count_parser.set_defaults(func=base_entry_count)\n",
    "    disp_ents_needed_parser.set_defaults(func=base_entries_needed)\n",
    "    \n",
    "    @cmd2.with_argparser(disp_parser)\n",
    "    def do_display(self, args):\n",
    "        \"\"\"display command help\"\"\"\n",
    "        func = getattr(args, 'func', None)\n",
    "        if func is not None:\n",
    "            # Call whatever subcommand function was selected\n",
    "            func(self, args)\n",
    "        else:\n",
    "            # No subcommand was provided, so call help\n",
    "            self.do_help('exp')\n",
    "        \n",
    "    count_parser = argparse.ArgumentParser()\n",
    "    count_parser.add_argument('-d','--date_range', nargs=2, help='start date, end_date')     \n",
    "\n",
    "    #delete section\n",
    "    \n",
    "    del_parser = argparse.ArgumentParser()\n",
    "    del_parser.add_argument('-ty', '--item_type',\n",
    "                            help='item type e.g. entry, category, section, author, publication')\n",
    "    del_parser.add_argument('-id', '--id_value', help='item id')\n",
    "    \n",
    "    @cmd2.with_argparser(del_parser)\n",
    "    def do_delete_item(self, args):\n",
    "        '''Delete item '''\n",
    "        warnings.warn('Unified delete function not fully tested')\n",
    "        app.delete_item(session=a.d.session, model=args.item_type, id_value=args.id_value)\n",
    "    \n",
    "    def do_exit(self, arg):\n",
    "        '''Exits the program, any existing database connections will be closed'''\n",
    "        a.close()\n",
    "        print('Exiting Languages Roundup')\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "-f is not a recognized command, alias, or macro\n",
      "/Users/thomassullivan/Library/Jupyter/runtime/kernel-6b82230c-792b-4551-b8d0-f26a9e44cb89.json is not a recognized command, alias, or macro\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " exit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exiting Languages Roundup\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    a=app.App()\n",
    "    a.setup()\n",
    "    RoundupCMD().cmdloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.d.session.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/thomassullivan/projects/GitHub/roundup_three'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exit\n"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}