ch14-callables-runnables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Callable & runnable objects (Chap 14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Anonymous Functions (Procs)\n",
    "- lambdas *are* procs, but with slightly different internal structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy from inside a proc.\n"
     ]
    }
   ],
   "source": [
    "# intro\n",
    "pr = Proc.new {puts \"howdy from inside a proc.\"}\n",
    "pr.call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "i'm a block or proc or something.\n",
      "LARRY\n",
      "MOE\n",
      "CURLY\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"larry\", \"moe\", \"curly\"]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# procs vs blocks - not every code block serves as the basis for a proc.\n",
    "# not a proc:\n",
    "[1,2,3].each {|x| puts x*10} \n",
    "\n",
    "# proc:\n",
    "def myproc(&block)\n",
    "    block.call\n",
    "end\n",
    "myproc {puts \"i'm a block or proc or something.\"}\n",
    "\n",
    "# proc can be in a code block:\n",
    "p = Proc.new {|x| puts x.upcase}\n",
    "%w{larry moe curly}.each(&p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- capturing a code block as a proc: the \"phantom\" proc creation step explains why the &-based syntax is needed. (Without the flag, Ruby has no way of knowing that you want to stop binding params to regular arguments, and instead performa a block-to-proc conversion.)\n",
    "![capture](px/Selection_175.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "got a block as a proc.\n",
      "inside a block.\n"
     ]
    }
   ],
   "source": [
    "def capture_block(&block)\n",
    "    puts \"got a block as a proc.\"\n",
    "    block.call\n",
    "end\n",
    "capture_block {puts \"inside a block.\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "got a block as a proc.\n",
      "howdy. i'm a proc argument, serving as a code block.\n"
     ]
    }
   ],
   "source": [
    "# using procs for blocks\n",
    "p = Proc.new { puts \"howdy. i'm a proc argument, serving as a code block.\"}\n",
    "capture_block(&p)\n",
    "\n",
    "# FYI: the & operator here is a wrapper for to_proc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To Pimp a Butterfly\n",
      "[\"Straight Outta Compton\", \"The Score\"]\n",
      "[nil, nil, nil, \"Midnight Marauders\", nil, nil, \"The Score\", nil, nil, nil]\n",
      "[\"Midnight Marauders\", \"The Score\"]\n"
     ]
    }
   ],
   "source": [
    "# Hash#to_proc\n",
    "# typically used to run multiple lookups at once.\n",
    "\n",
    "albums = { \n",
    "        1988 => \"Straight Outta Compton\", \n",
    "        1993 => \"Midnight Marauders\",\n",
    "        1996 => \"The Score\", 2004 => \"Madvillainy\",\n",
    "        2015 => \"To Pimp a Butterfly\" }\n",
    "\n",
    "puts albums[2015] # single lookup\n",
    "puts [1988,1996].map(&albums) # multi lookups\n",
    "puts (1990..1999).map(&albums) # using a range\n",
    "puts (1990..1999).map(&albums).compact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"david\", \"joe\"]\n"
     ]
    }
   ],
   "source": [
    "# generalizing to_proc\n",
    "# gives an idea of the power of to_proc\n",
    "class Person\n",
    "    attr_accessor :name\n",
    "    def self.to_proc\n",
    "        Proc.new {|p| p.name}\n",
    "    end\n",
    "end\n",
    "d = Person.new; d.name = \"david\"\n",
    "j = Person.new; j.name = \"joe\"\n",
    "puts [d,j].map(&Person)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Moe\", \"Larry\", \"Curly\"]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Symbol#to_proc (here, :capitalize is a symbol)\n",
    "%w{ moe larry curly }.map(&:capitalize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# procs as closures\n",
    "def multiply_by(m)\n",
    "    Proc.new {|x| puts x*m}\n",
    "end\n",
    "mult = multiply_by(10)\n",
    "mult.call(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'a' to be used in proc block\n",
      "irrelevant 'a' in method scope\n",
      "'a' to be used in proc block\n"
     ]
    }
   ],
   "source": [
    "# notice how the Proc object carries it context with it. (a closure.)\n",
    "def callme(pr)\n",
    "    a = \"irrelevant 'a' in method scope\"\n",
    "    puts a \n",
    "    pr.call\n",
    "end\n",
    "a = \"'a' to be used in proc block\"\n",
    "pr = Proc.new {puts a}\n",
    "pr.call\n",
    "callme(pr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# classic closure example: a counter\n",
    "def make_counter\n",
    "    n=0\n",
    "    return Proc.new {n+=1}\n",
    "end\n",
    "c = make_counter; puts c.call; puts c.call\n",
    "d = make_counter; puts d.call; puts c.call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "called with argument 100\n",
      "nil\n"
     ]
    }
   ],
   "source": [
    "# proc params & arguments\n",
    "p1 = Proc.new {|x| puts \"called with argument #{x}\"}\n",
    "p2 = Proc.new {|x| p x}\n",
    "p1.call(100)\n",
    "p2.call"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### creating functions with lambda and ->\n",
    "- lambdas expect correct number of arguments\n",
    "- lambdas require explicit creation\n",
    "- lambdas with embedded \"return\" trigger immediate exit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i'm a lambda.\n",
      "still here\n"
     ]
    }
   ],
   "source": [
    "# intro\n",
    "lam = lambda {puts \"i'm a lambda.\"}\n",
    "lam.call\n",
    "\n",
    "def rtn_test\n",
    "    l = lambda {return}\n",
    "    l.call\n",
    "    puts \"still here\"\n",
    "    p = Proc.new {return}\n",
    "    p.call\n",
    "    puts \"you should'nt see this\"\n",
    "end\n",
    "rtn_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# \"stabby lambda\" (->)\n",
    "lam =  ->      {puts \"howdy.\"}\n",
    "mult = ->(x,y) {x*y}\n",
    "\n",
    "lam.call; mult.call(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Methods as objects\n",
    "- Methods don’t present themselves as objects until you tell them to. Treating methods as objects involves objectifying them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "method grabber: self is #<C:0x00005587913ef3a0>.\n"
     ]
    }
   ],
   "source": [
    "# capturing method objects\n",
    "class C\n",
    "    def talk\n",
    "        puts \"method grabber: self is #{self}.\"\n",
    "    end\n",
    "end\n",
    "c = C.new; meth = c.method(:talk); puts meth.owner\n",
    "meth.call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "method grabber: self is #<D:0x0000558791366050>.\n"
     ]
    }
   ],
   "source": [
    "# unbinding method from an object, rebinding it to another\n",
    "class D<C\n",
    "end\n",
    "d = D.new; unbound = meth.unbind; unbound.bind(d).call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# why methods as objects\n",
    "# suppose i've got a class hierarchy where a method is redefined?\n",
    "\n",
    "# TODO: SOLVE SUPERCLASS MISMATCH ERROR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Eval methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# eval: arbitrary strings as code\n",
    "eval(\"2+2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "false\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "(pry):125: warning: $SAFE will become a normal global variable in Ruby 3.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# eval dangers\n",
    "# - VERY EASY to allow destructive behavior, ie \"rm -rf /*\"\n",
    "# Object.tainted? flags potentially insecure data, ie from \"gets\".\n",
    "x = \"some bogus user input\" # instead of using gets\n",
    "puts x.tainted?\n",
    "\n",
    "# $SAFE: 0 by default; \n",
    "# 1 = raises SecurityError is eval tried on tainted data\n",
    "puts $SAFE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main\n",
      "[]\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "#<Person:0x0000558790c1d7a8 @name=\"joe\", @age=37>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# instance_eval - evals string or code block \n",
    "# changes self to be the call receiver\n",
    "p self\n",
    "a = []; a.instance_eval {p self}\n",
    "\n",
    "# usually used to peek into another object's private data,\n",
    "# esp instance variables. (considered impolite.)\n",
    "class C\n",
    "    def initialize\n",
    "        @x=1\n",
    "    end\n",
    "end\n",
    "c = C.new; c.instance_eval {puts @x}\n",
    "\n",
    "# another use case: simplified assignments\n",
    "class Person\n",
    "    def initialize(&block)\n",
    "        instance_eval(&block)\n",
    "    end\n",
    "    def name(name=nil)\n",
    "        @name ||= name\n",
    "    end\n",
    "    def age(age=nil)\n",
    "        @age ||= age\n",
    "    end\n",
    "end\n",
    "joe = Person.new do \n",
    "    name \"joe\"\n",
    "    age 37\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "created in class eval\n"
     ]
    }
   ],
   "source": [
    "# class_eval (aka module_eval)\n",
    "c = Class.new\n",
    "c.class_eval do\n",
    "    def dothis\n",
    "        puts \"created in class eval\"\n",
    "    end\n",
    "end\n",
    "c_instance = c.new; c_instance.dothis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Threads\n",
    "- Ruby’s threads allow you to do multiple tasks via time sharing (one thread executes instructions, passes control to the next thread, etc.)\n",
    "- Ruby will try to use native OS threading & will otherwise fall back to \"green threads\" (implemented inside the interpreter).\n",
    "\n",
    "- Parallelism and concurrency are NOT identical. Parallelism ensures that two or more tasks can run at the **exact** same time; concurrency only ensures a sort of time sharing that allows for faster processing. \n",
    "\n",
    "- Ruby uses a Global Interpreter Lock (GIL). It helps to ensure thread safety in concurrent programming but prevents parallelism.\n",
    "\n",
    "- In this section, we’ll discuss concurrency as it refers to the execution of multiple threads, regardless of whether they run in parallel. Actual behavior will depend on your hardware and Ruby implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting...\n",
      "outside thread.\n"
     ]
    }
   ],
   "source": [
    "# intro\n",
    "Thread.new do \n",
    "    puts \"starting...\"; sleep 1\n",
    "    puts \"...ending.\"\n",
    "end\n",
    "puts \"outside thread.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outside thread\n",
      "starting...\n",
      "...ending.\n",
      "...ending.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "#<Thread:0x00005587919e7780 (pry):171 dead>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# join: allowing thread to finish \n",
    "t = Thread.new do \n",
    "    puts \"starting...\"; sleep 1\n",
    "    puts \"...ending.\"\n",
    "end\n",
    "puts \"outside thread\"; t.join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying to read file\n",
      "msg from thread: failed on n=0\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "# killing, stopping, starting threads\n",
    "# example use case: exception occurs inside a thread.\n",
    "puts \"trying to read file\"\n",
    "t = Thread.new do \n",
    "    (0..2).each do |n|\n",
    "        begin\n",
    "            File.open(\"part0#{n}\") do |f|\n",
    "                text << f.readlines\n",
    "            end\n",
    "            rescue Errno::ENOENT\n",
    "                puts \"msg from thread: failed on n=#{n}\"\n",
    "            Thread.exit\n",
    "        end\n",
    "    end\n",
    "end\n",
    "t.join; puts \"done\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy\n",
      "back to the fiber\n",
      "nice day\n",
      "one last msg from the fiber\n",
      "bye\n",
      "that's it.\n"
     ]
    }
   ],
   "source": [
    "# fibers == re-entrant code blocks == basis of enumerators.\n",
    "f = Fiber.new do \n",
    "    puts \"howdy\"\n",
    "    Fiber.yield\n",
    "    puts \"nice day\"\n",
    "    Fiber.yield\n",
    "    puts \"bye\"\n",
    "end\n",
    "f.resume\n",
    "puts \"back to the fiber\"\n",
    "f.resume\n",
    "puts \"one last msg from the fiber\"\n",
    "f.resume\n",
    "puts \"that's it.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# threaded date server\n",
    "# DO OUTSIDE JUPYTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# chat server with sockets & threads\n",
    "# DO OUTSIDE JUPYTER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# threads & variables\n",
    "a=1\n",
    "Thread.new {a=2}\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "t = Thread.new {Thread.stop; a=3}\n",
    "puts a\n",
    "t.run\n",
    "puts a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[:message]\n",
      "howdy\n",
      "\"marco.\"\n",
      "\"polo.\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"polo.\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# thread keys - storage hash for thread-specific values\n",
    "t = Thread.new do \n",
    "    Thread.current[:message]=\"howdy\"\n",
    "end\n",
    "t.join\n",
    "p t.keys\n",
    "puts t[:message]\n",
    "\n",
    "# note: even though thread is \"dead\", you can still query the keys.\n",
    "# or you can use fetch to get values & assign defaults.\n",
    "\n",
    "t = Thread.new do \n",
    "    Thread.current[:message]=\"marco.\"\n",
    "end\n",
    "t.join\n",
    "p t.fetch(:message, \"polo.\")\n",
    "p t.fetch(:msg,     \"polo.\")\n",
    "# p t.fetch(:msg) <== this raises a KeyError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rock-paper-scissors\n",
    "# TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### System commands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "pid 24417 exit 0\n",
      "\n",
      "pid 24418 exit 127\n"
     ]
    }
   ],
   "source": [
    "# system method, exec method, backticks\n",
    "puts system(\"date\")\n",
    "puts $? # process ID just completed, and status.\n",
    "puts system(\"bogus\")\n",
    "puts $?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Sep 22 12:57:07 CDT 2020\n",
      "\n",
      "ch01-bootstrap.ipynb\n",
      "ch02-objs-meths-locals.ipynb\n",
      "ch03-classes.ipynb\n",
      "ch04-modules.ipynb\n",
      "ch05-self.ipynb\n",
      "ch07-essentials.ipynb\n",
      "ch08-scalars.ipynb\n",
      "ch09-collections-containers.ipynb\n",
      "ch10-enumerables.ipynb\n",
      "ch11-regexes.ipynb\n",
      "ch12-file-io.ipynb\n",
      "ch13-object-individualization.ipynb\n",
      "ch14-callables-runnables.ipynb\n",
      "ch15-callbacks-hooks-introspection.ipynb\n",
      "ch16-functional-programming.ipynb\n",
      "px\n",
      "well-grounded-rubyist.ipynb\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# backticks -- returns program output\n",
    "puts `date`\n",
    "puts `ls`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"ch01-bootstrap.ipynb\\nch02-objs-meths-locals.ipynb\\nch03-classes.ipynb\\nch04-modules.ipynb\\nch05-self.ipynb\\nch07-essentials.ipynb\\nch08-scalars.ipynb\\nch09-collections-containers.ipynb\\nch10-enumerables.ipynb\\nch11-regexes.ipynb\\nch12-file-io.ipynb\\nch13-object-individualization.ipynb\\nch14-callables-runnables.ipynb\\nch15-callbacks-hooks-introspection.ipynb\\nch16-functional-programming.ipynb\\npx\\nwell-grounded-rubyist.ipynb\\n\""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# %x = alias for backticks\n",
    "%x(\"ls\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exec - same behavior as system and backticks\n",
    "# replaces current process with new shell.\n",
    "# (system & backticks uses \"fork\" to run command in a subshell.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# communicating with programs - open, popen3\n",
    "# TODO"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.7.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}