labs/shortest_path/shortest_path_inventory_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling the Inventory Problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic idea of the inventory problem is to satify a demand of beams in the most cost-effective way possible. Given a demand of different size beams, which sizes are the cheapest to keep in your inventroy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "import numpy as np\n",
    "from random import randint\n",
    "from functools import partial\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets start with a simple demand of a 3, 4, and 5 foot beams. Enumerate each possibility below to find the most cost-effective inventory for the given demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GUI\n",
    "master = Tk()\n",
    "master.geometry(\"1600x850\")\n",
    "master.title(\"The Inventory Problem - Toy Example\")\n",
    "\n",
    "# Canvas\n",
    "canvas = Canvas(master, width=1200, height=750, background='white')\n",
    "canvas.grid(row=0, column=1, rowspan=15, columnspan=3)\n",
    "canvas.create_line(0, 690, 1200, 690)\n",
    "canvas.create_line(0, 440, 1200, 440)\n",
    "canvas.create_line(0, 240, 1200, 240)\n",
    "\n",
    "\n",
    "# Functions\n",
    "def draw_beams(counts, heightAdjust):\n",
    "    canvas.delete(\"height450\")\n",
    "    for count in range(3):\n",
    "        for i in range(counts[count]):\n",
    "            canvas.create_rectangle(400*(count + 1) + i*50 - 320, 220 - 70*(count + 1) + heightAdjust, 400*(count + 1) +i*50 - 350, 220 + heightAdjust, outline=\"#fb0\", fill=\"#fb0\", tags=\"height\"+(str)(heightAdjust))\n",
    "\n",
    "def select_arcs(arc_list):\n",
    "    canvas.delete(\"arc\")\n",
    "    global costs\n",
    "    costs=[None,0,0,0]\n",
    "    for arc in arc_list:\n",
    "        costs[arc[1]] = arcs[arc[0], arc[1]]\n",
    "        if arc[1] - arc[0] == 1:\n",
    "            canvas.create_line(320*arc[0]+55, 280, 320*arc[1]+15,280, fill=\"red\", width=5, tags=\"arc\")\n",
    "        elif arc[1] - arc[0] == 2:\n",
    "            canvas.create_arc(320*arc[0] + 35, 230, 320*arc[1] +35, 370, start=180, extent=180, style=\"arc\", outline=\"red\",width=5, tags=\"arc\")\n",
    "        else:\n",
    "            canvas.create_arc(320*arc[0] + 35, 170, 320*arc[1] +35, 430, start=180, extent=180, style=\"arc\", outline=\"red\",width=5,tags=\"arc\")\n",
    "    \n",
    "def select_node(size):\n",
    "    canvas.create_oval(320*(size+1) +15, 260, 320*(size+1)+55,300, fill='yellow', tags=(\"selected\",\"a\" + (str)(size)))\n",
    "    canvas.create_text(320*(size+1) +35, 280, text=(str)(size+3), tags=(\"selected\",\"a\" +(str)(size)))\n",
    "\n",
    "def draw_costs():\n",
    "    canvas.delete(\"cost\")\n",
    "    for i in range(1,4):\n",
    "        canvas.create_text(400*i -285, 720, text=\"$\" + (str)(costs[i]),font=\"Ariel 20\",tags=\"cost\")\n",
    "    canvas.create_text(1100, 720, text=\"$\" + (str)(costs[1] + costs[2] + costs[3]), font=\"Ariel 20\",tags=\"cost\")\n",
    "    \n",
    "def switch(size):\n",
    "    if inUse[size]:\n",
    "        inUse[size] = False\n",
    "        canvas.delete(\"a\"+(str)(size))\n",
    "    else:\n",
    "        inUse[size] = True\n",
    "        select_node(size)\n",
    "    update_inv()\n",
    "    \n",
    "def update_inv():\n",
    "    global inventory\n",
    "    if inUse[0] and inUse[1]:\n",
    "        inventory = [3,1,2]\n",
    "        select_arcs([[0,1],[1,2],[2,3]])\n",
    "    elif inUse[0]:\n",
    "        inventory = [3,0,3]\n",
    "        select_arcs([[0,1],[1,3]])\n",
    "    elif inUse[1]:\n",
    "        inventory = [0,4,2]\n",
    "        select_arcs([[0,2],[2,3]])\n",
    "    else:\n",
    "        inventory = [0,0,6]\n",
    "        select_arcs([[0,3]])\n",
    "    draw_costs()\n",
    "    draw_beams(inventory, 450)\n",
    "\n",
    "# Side Labels\n",
    "inputLabel = Label(master, text= \"Inputs: \", font = \"Ariel 20\", justify = \"left\")\n",
    "inputLabel.grid(row=0, column=0)\n",
    "\n",
    "graphLabel = Label(master, text= \"Graph: \", font = \"Ariel 20\", justify = \"left\")\n",
    "graphLabel.grid(row=5, column=0)\n",
    "\n",
    "outputLabel = Label(master, text= \"Feasible Solution: \", font = \"Ariel 20\", justify = \"left\")\n",
    "outputLabel.grid(row=10, column=0)\n",
    "\n",
    "switches = [None] * 3\n",
    "for i in range(2):\n",
    "    switches[i] = Button(master, text=\"Stock / Unstock Length \" + (str)(i+3) +\" Beams\", command=partial(switch,i))\n",
    "    switches[i].grid(row=i+11, column=0)\n",
    "switches[2] = Label(master, text= \"Cannot Unstock Length 5 Beams\")\n",
    "switches[2].grid(row=13, column=0)\n",
    "\n",
    "costLabel = Label(master, text= \"Total Cost: \", font = \"Ariel 20\", justify = \"left\")\n",
    "costLabel.grid(row=14, column=0)\n",
    "\n",
    "# Inputs\n",
    "demand = [3,1,2]\n",
    "draw_beams(demand, 0)\n",
    "storageCosts = [None, 5, 11, 15]\n",
    "beamCosts = [None, 4, 7, 8]\n",
    "\n",
    "canvas.create_text(295, 190, text=\"Length: 3 feet\\nStorage Cost: $5.00\\nBeam Cost: $4.00\", font=\"Ariel 20\")\n",
    "canvas.create_text(600, 190, text=\"Length: 4 feet\\nStorage Cost: $11.00\\nBeam Cost: $7.00\", font=\"Ariel 20\")\n",
    "canvas.create_text(1050, 190, text=\"Length: 5 feet\\nStorage Cost: $15.00\\nBeam Cost: $8.00\", font=\"Ariel 20\")\n",
    "\n",
    "\n",
    "# Feasible Solutions\n",
    "inventory = [0,0,6]\n",
    "draw_beams(inventory, 450)\n",
    "\n",
    "costs=[None,0,0,0]\n",
    "\n",
    "# Graph\n",
    "# Nodes\n",
    "canvas.create_oval(15, 260, 55,300, fill=\"yellow\")\n",
    "canvas.create_text(35, 280, text=\"Start\")\n",
    "for i in range(1,4):\n",
    "    canvas.create_oval(320*i + 15, 260, 320*i + 55,300, fill=\"orange\")\n",
    "    canvas.create_text(320*i +35, 280, text=(str)(i+2))\n",
    "    \n",
    "# Arcs\n",
    "arcs = np.zeros((4,4))\n",
    "for i in range(4):\n",
    "    for j in range(1,4):\n",
    "        if i < j:\n",
    "            if j-i == 1:\n",
    "                canvas.create_line(320*i+55, 280, 320*j+15,280)\n",
    "                arcs[i,j] = storageCosts[j] + beamCosts[j] * demand[j-1]\n",
    "                canvas.create_text(160*(i+j) +20, 260, text=(str)(storageCosts[j]) + \" + \" + (str)(beamCosts[j]) + \"(\" + (str)(demand[j-1]) + \") = \" + (str)(arcs[i,j]), font=\"Ariel 15\")\n",
    "            elif j-i == 2:\n",
    "                canvas.create_arc(320*i + 35, 230, 320*j +35, 370, start=180, extent=180, style=\"arc\")\n",
    "                arcs[i,j] = storageCosts[j] + beamCosts[j] * (demand[j-1] + demand[j-2])\n",
    "                canvas.create_text(160*(i+j) +20, 350, text=(str)(storageCosts[j]) + \" + \" + (str)(beamCosts[j]) + \"(\" + (str)(demand[j-1] + demand[j-2]) + \") = \" + (str)(arcs[i,j]), font=\"Ariel 15\")\n",
    "            else:\n",
    "                canvas.create_arc(320*i + 35, 170, 320*j +35, 430, start=180, extent=180, style=\"arc\")\n",
    "                arcs[i,j] = storageCosts[j] + beamCosts[j] * (demand[j-1] + demand[j-2] + demand[j-3])\n",
    "                canvas.create_text(160*(i+j) +20, 410, text=(str)(storageCosts[j]) + \" + \" + (str)(beamCosts[j]) + \"(\" + (str)(demand[j-1] + demand[j-2] + demand[j-3]) + \") = \" + (str)(arcs[i,j]), font=\"Ariel 15\")\n",
    "    \n",
    "# Costs\n",
    "canvas.create_text(310, 720, text=\"+\", font=\"Ariel 20\")\n",
    "canvas.create_text(710, 720, text=\"+\", font=\"Ariel 20\")\n",
    "canvas.create_text(1000, 720, text=\"=\", font=\"Ariel 20\")\n",
    "\n",
    "inUse = [False,False,False]\n",
    "switch(2)\n",
    "\n",
    "# mainloop\n",
    "windowOpen=True\n",
    "while windowOpen:\n",
    "    try:\n",
    "        master.update_idletasks()\n",
    "        master.update()\n",
    "    except TclError:\n",
    "        windowOpen=False\n",
    "        print(\"window successfully closed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have solved a simple example of the inventory problem, try using the following model to solve larger inputs with a graphical visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GUI\n",
    "master = Tk()\n",
    "master.geometry(\"1600x750\")\n",
    "master.title(\"The Inventory Problem\")\n",
    "\n",
    "# Button Functions\n",
    "started = False\n",
    "def shuffle():\n",
    "    global demand\n",
    "    global started\n",
    "    started = True\n",
    "    canvas.delete(\"pipe\")\n",
    "    canvas.delete(\"arc\")\n",
    "    canvas.delete(\"selected\")\n",
    "    canvas.delete(\"shuffle\")\n",
    "    global on\n",
    "    on = [False] * 11\n",
    "    drawOutcome(False)\n",
    "    # resets demand and inventory to 0 for all sizes\n",
    "    demand= np.zeros(11)\n",
    "    inventory= np.zeros(11)\n",
    "    \n",
    "    update()\n",
    "    \n",
    "    newDemand = [None]* 10\n",
    "    # last storage and per cost, so that they are always increasing in cost as size increases\n",
    "    lastS = 1\n",
    "    lastP = 1\n",
    "    \n",
    "    storageLabels = [None] * 10\n",
    "    perCostLabels = [None] * 10\n",
    "    # Randomize new storage and pipe costs\n",
    "    for i in range(10):\n",
    "        newS = randint(lastS, 40 * (i+1))\n",
    "        newP = randint(lastP, 10 * (i+1))\n",
    "        storageCost[i+1] = newS\n",
    "        perCost[i+1] = newP\n",
    "        lastS = newS + 1\n",
    "        lastP = newP + 1\n",
    "        canvas.create_text(117*(i+1) -24, 500, text=\"$\" + (str)(storageCost[i+1]), font=\"Courier 20\", tags=\"shuffle\")\n",
    "        canvas.create_text(117*(i+1) -24, 570, text=\"$\" + (str)(perCost[i+1]), font=\"Courier 20\", tags=\"shuffle\")\n",
    "    # Randomize new demand\n",
    "    for i in range(10):\n",
    "        newDemand[i] = randint(1, 10)\n",
    "        demand[newDemand[i]] +=1\n",
    "        if demand[newDemand[i]] == 1:\n",
    "            canvas.create_rectangle(117 * newDemand[i] - 49, 220- 20*newDemand[i], 117*newDemand[i] + 1, 220, outline=\"#fb0\", fill=\"#fb0\", tags=\"pipe\")\n",
    "            sizeStr= \"Size: \" + (str)(newDemand[i])\n",
    "            canvas.create_text(117 * newDemand[i] - 24, 220, fill=\"darkblue\", font=\"Ariel 10\",text=sizeStr, tags=\"pipe\")\n",
    "            numStr= \"Demand: \" + (str)((int)(demand[newDemand[i]]))\n",
    "            canvas.create_text(117 * newDemand[i] - 24, 220- 20*newDemand[i], fill=\"darkblue\", font=\"Ariel 10\",text=numStr, tags=(\"pipe\", \"d\" + (str)(newDemand[i])))\n",
    "        else:\n",
    "            canvas.delete(\"d\" + (str)(newDemand[i]))\n",
    "            numStr= \"Demand: \" + (str)((int)(demand[newDemand[i]]))\n",
    "            canvas.create_text(117 * newDemand[i] - 24, 220- 20*newDemand[i], fill=\"darkblue\", font=\"Ariel 10\",text=numStr, tags=(\"pipe\", \"d\" + (str)(newDemand[i])))\n",
    "            \n",
    "    obj_func()\n",
    "    k = 10\n",
    "    loop = True\n",
    "    global minNode\n",
    "    while k > 1 and loop:\n",
    "        if demand[k] > 0:\n",
    "            minNode = k\n",
    "            loop = False\n",
    "        k -=1\n",
    "\n",
    "# Arcs\n",
    "A = np.zeros((11,11))\n",
    "isArc = [[False for j in range(11)] for i in range(11)]\n",
    "minNode = 10\n",
    "\n",
    "# Objective Function\n",
    "def obj_func(): # assigns values to array based on how many characters are in a line from the row's word to column's word and compares this with L\n",
    "    global A\n",
    "    global isArc\n",
    "    isArc = [[False for j in range(11)] for i in range(11)]\n",
    "    A = np.zeros((11,11))\n",
    "    for i in range(len(A)):\n",
    "        for j in range(len(A)): # uses 2D array to iterate over all n words\n",
    "            if i < j:\n",
    "                isArc[i][j] = True\n",
    "                A[i,j] += storageCost[j]\n",
    "                for k in range(i+1, j+1):  \n",
    "                    A[i,j] += perCost[j] * demand[k]\n",
    "        \n",
    "# dijkstras algorithm\n",
    "def dijkstras(A, s=0):\n",
    "    d = [float('inf')] * len(A) # distance of path (cost to get larger pipe)\n",
    "    p = [float('nan')] * len(A) # previous\n",
    "    S, F = [], [] # S-searched, F-frontier\n",
    "    F.append(s)\n",
    "    d[s] = 0\n",
    "\n",
    "    while len(F) > 0: # While there are items within the frontier\n",
    "        F.sort(reverse=True, key=lambda x: d[x])\n",
    "        f = F.pop() # Takes last item of F as f\n",
    "        S.append(f) # Settles f\n",
    "        for w in range(len(A)): # Iterates through the length of A (The amount of pipe lengths)\n",
    "            if isArc[f][w]: # Check if we are looking at an arc\n",
    "                if w not in S and w not in F: # If the node is not settled or in the frontier:\n",
    "                    d[w] = d[f] + A[f][w] # Adds the node's cost to the list of distances\n",
    "                    p[w] = f # Adds the current node f as the prev for the node being looked at\n",
    "                    F.append(w) # Add the node being looked at to the frontier.\n",
    "                else: # If the node being looked at is already in the frontier:\n",
    "                    if d[f] + A[f][w] < d[w]: # If the path to the node through the current node f is shorter than its previous path:\n",
    "                        d[w] = d[f] + A[f][w] # Update the distance to the node to be that of the path through F\n",
    "                        p[w] = f # Update the prev of the node to be f\n",
    "    return p        \n",
    "    \n",
    "# return string output\n",
    "def formatOutput(p):\n",
    "    global minNode\n",
    "    path=[minNode]\n",
    "    nextNode = minNode\n",
    "    while not math.isnan(p[nextNode]):\n",
    "        nextNode = p[nextNode]\n",
    "        path.append(nextNode)\n",
    "    return path       \n",
    "        \n",
    "        \n",
    "def optimize():\n",
    "    canvas.delete(\"selected\")\n",
    "    canvas.delete(\"arc\")\n",
    "    global on\n",
    "    on = [False] * 11\n",
    "    global inventory\n",
    "    inventory= np.zeros(11)\n",
    "    global costVar\n",
    "    costVar.set(\"$0\")\n",
    "    nodes = formatOutput(dijkstras(A,s=0))\n",
    "    for i in nodes:\n",
    "        if i != 0:\n",
    "            switch(i)\n",
    "\n",
    "# Canvas\n",
    "canvas = Canvas(master, width=1200, height=600, background='white')\n",
    "canvas.grid(row=0, column=1, rowspan=9, columnspan=11)\n",
    "\n",
    "# Top Labels\n",
    "label1 = Label(master, text= \"Demand: \", font = \"Ariel 20\", justify = \"left\")\n",
    "label1.grid(row=0, column=0)\n",
    "\n",
    "label2 = Label(master, text= \"Graph: \", font = \"Ariel 20\", justify = \"left\")\n",
    "label2.grid(row=3, column=0)\n",
    "\n",
    "# Top Buttons\n",
    "shuffle = Button(master, text=\"Start / Shuffle\", command=shuffle)\n",
    "shuffle.grid(row=1, column=0)\n",
    "\n",
    "optimize = Button(master, text=\"Optimize\", command=optimize)\n",
    "optimize.grid(row=4, column=0)\n",
    "\n",
    "# Variables\n",
    "storageCost = [None] * 11\n",
    "perCost = [None] * 11\n",
    "totalCost = 0\n",
    "\n",
    "demand= np.zeros(11) #demand[3] = 5 means there is are 5 demands for a 3 foot beam\n",
    "inventory= np.zeros(11)\n",
    "\n",
    "# Cost Labels\n",
    "storageCostLabel = Label(master, text= \"Storage Area Cost: \", font = \"Ariel 20\", justify = \"left\")\n",
    "storageCostLabel.grid(row=7, column=0)\n",
    "\n",
    "perCostLabel = Label(master, text= \"Cost per Beam: \", font = \"Ariel 20\", justify = \"left\")\n",
    "perCostLabel.grid(row=8, column=0)\n",
    "\n",
    "costLabel = Label(master, text= \"Total Cost: \", font = \"Ariel 20\", justify = \"left\")\n",
    "costLabel.grid(row=5, column=0)\n",
    "\n",
    "costVar = StringVar()\n",
    "costVar.set(\"$0\")\n",
    "costVarLabel = Label(master, textvariable= costVar, font = \"Ariel 30\", justify = \"left\")\n",
    "costVarLabel.grid(row=6, column=0)\n",
    "  \n",
    "    \n",
    "# Demand Satisfied/ Unsatisfied Check\n",
    "def drawOutcome(outcome):\n",
    "    canvas.delete(\"outcome\")\n",
    "    if not outcome:\n",
    "        solved = \"red\"\n",
    "        solvedtxt = \"Demand Not Met\"\n",
    "    else:\n",
    "        solved = \"green\"\n",
    "        solvedtxt = \"Demand Satisfied\"\n",
    "    canvas.create_text(150, 30, fill=solved, font=\"Ariel 20\",text=solvedtxt, tags=\"outcome\")\n",
    "drawOutcome(False)    \n",
    "    \n",
    "def check():\n",
    "    highestD = 0\n",
    "    highestI = 0\n",
    "    for i in range(1, 11):\n",
    "        if demand[i] > 0:\n",
    "            highestD = i\n",
    "        if inventory[i] > 0:\n",
    "            highestI = i\n",
    "    if highestD > highestI:\n",
    "        drawOutcome(False)\n",
    "    else:\n",
    "        drawOutcome(True)\n",
    "        \n",
    "# Nodes\n",
    "nodes = [None] * 11\n",
    "canvas.create_oval(5, 275, 55, 325, fill=\"yellow\")\n",
    "canvas.create_text(30, 300, text=\"Start\")\n",
    "for i in range(1, 11):\n",
    "    canvas.create_oval(117*i - 44, 280, 117*i -4,320, fill=\"orange\")\n",
    "    canvas.create_text(117*i -24, 300, text=(str)(i))\n",
    "    \n",
    "\n",
    "# When Node is added / removed            \n",
    "on = [False] * 11\n",
    "def switch(size):\n",
    "    if started:\n",
    "        global totalCost\n",
    "        #turn off\n",
    "        if on[size]:\n",
    "            inventory[size] = 0\n",
    "            on[size] = False\n",
    "            canvas.delete(\"a\" + (str)(size))\n",
    "        #turn on\n",
    "        else:\n",
    "            on[size] = True\n",
    "            canvas.create_oval(117*size - 49, 275, 117*size + 1, 325, fill='yellow', tags=(\"selected\",\"a\" + (str)(size)))\n",
    "            canvas.create_text(117*size -24, 300, text=(str)(size), tags=(\"selected\",\"a\" +(str)(size)))\n",
    "        update()\n",
    "        check()\n",
    "        updatePath()\n",
    "            \n",
    "\n",
    "def update():\n",
    "    global totalCost\n",
    "    global yourCost\n",
    "    totalCost = 0\n",
    "    global inventory\n",
    "    inventory = np.zeros(11)\n",
    "    search = True\n",
    "    i = 10\n",
    "    atNode = 10\n",
    "    while search and i >= 1 and atNode>=1:\n",
    "        loop = True\n",
    "        atNode = i\n",
    "        while on[atNode] and i >= 1 and loop:\n",
    "            inventory[atNode] += demand[i]\n",
    "            if on[i -1]:\n",
    "                loop = False\n",
    "            i -=1\n",
    "        if inventory[atNode] >= 1:\n",
    "            totalCost += (int)(storageCost[atNode] + inventory[atNode] * perCost[atNode])\n",
    "        atNode -=1\n",
    "        if loop:\n",
    "            i -=1\n",
    "    costVar.set(\"$\" + (str)(totalCost))\n",
    "        \n",
    "        \n",
    "def updatePath():\n",
    "    canvas.delete(\"arc\")\n",
    "    prev = 0\n",
    "    for i in range(11):\n",
    "        if on[i]:\n",
    "            createArc(prev, i)\n",
    "            prev = i\n",
    "            \n",
    "def createArc(prev, node):\n",
    "    arcLocation = np.zeros(4)\n",
    "    textLocation = np.zeros(2)\n",
    "    if prev == 0:\n",
    "        arcLocation = [30, 250, 117*node -24, 400]\n",
    "        textLocation = [58.5*node + 3, 410]\n",
    "    else:\n",
    "        arcLocation= [117*prev -24, 250, 117*node -24, 400]\n",
    "        textLocation = [58.5*(node + prev) - 24, 410]\n",
    "    canvas.create_arc(arcLocation, start=180, extent=180, style=\"arc\", tags=\"arc\")\n",
    "    if inventory[node] == 0:\n",
    "        canvas.create_text(textLocation, text=\"0\", font = \"Ariel 12\", tags=\"arc\")\n",
    "    else:\n",
    "        canvas.create_text(textLocation, text=(str)(storageCost[node]) + \"+(\" + (str)((int)(inventory[node])) + \")\" + (str)(perCost[node]) + \"=\" + (str)((int)(storageCost[node] + inventory[node] * perCost[node])), font = \"Courier 12\", tags=\"arc\")\n",
    "        canvas.create_rectangle(117*node -49, 480, 117*node +1, 590, tags=\"arc\")\n",
    "    \n",
    "# Bottom Labels\n",
    "lengthLabel = Label(master, text= \"Length: \", font = \"Ariel 20\", justify = \"left\")\n",
    "lengthLabel.grid(row=10, column=0)\n",
    "numLabels = [None] * 10\n",
    "switches = [None] * 10\n",
    "for i in range(10):\n",
    "    numLabels[i] = Label(master, text=i+1, font = \"Ariel 20\", justify = \"left\")\n",
    "    numLabels[i].grid(row=9, column=i+2)\n",
    "    switches[i] = Button(master, text=\"On / Off\", command=partial(switch,i+1))\n",
    "    switches[i].grid(row=10, column=i+2)\n",
    "    \n",
    "# mainloop\n",
    "windowOpen=True\n",
    "while windowOpen:\n",
    "    try:\n",
    "        master.update_idletasks()\n",
    "        master.update()\n",
    "    except TclError:\n",
    "        windowOpen=False\n",
    "        print(\"window successfully closed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}