State Machines in Python - Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# State Machines in Python - Part 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## STMPY\n",
    "\n",
    "We will use a framework for State Machines in Python. The framework was created especially for this course and education purposes, and is open source. More about the code later. Let's first get started.\n",
    "\n",
    "### Check Installation\n",
    "\n",
    "Run the following cell. it should output the current version of stmpy you have installed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import stmpy\n",
    "print('STMPY Version installed: {}'.format(stmpy.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you haven't installed stmpy, install it via the following command line commands:\n",
    "\n",
    "`pip install stmpy`\n",
    "\n",
    "Or if you need to update to a newer version:\n",
    "\n",
    "`pip install --upgrade stmpy`\n",
    "\n",
    "Once you have done this  the command line, come back to this notebook and restart the kernel. (Grey menu bar at the top of this page, Kernel / Restart.) Then run the cell above again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started - Step by Step\n",
    "\n",
    "*In the following we go through the setup of a single state machine, almost line by line so all details are covered. Make sure to execute every notebook cell with Python code in it, and make sure it executes correctly without error message. The next tutorials will present code in a more compact way. So if you feel confident in Python and think this goes to slow, there's hope. If you struggle a bit with Python, have an extra close look at the details. Also, ask questions on Piazza.*\n",
    "\n",
    "Let's start with a simple state machine:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data:image/png;base64,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\" width=\"421\" height=\"122\" style=\"max-width:100%;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The state machine calls method `on_init()` when it starts, and goes into state `s_tick`. Then, it toggles basck and forth to the `s_tock` state, controlled by timers.\n",
    "\n",
    "Since this state machine works alongside Python code, the actions in the transitions directly refer to Python methods. We declare them in a dedicated class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Tick:\n",
    "\n",
    "    def on_init(self):\n",
    "        print('Init!')\n",
    "        self.ticks = 0\n",
    "        self.tocks = 0\n",
    "        self.stm.start_timer('tick', 1000)\n",
    "\n",
    "    def on_tick(self):\n",
    "        print('Tick! {}'.format(self.ticks))\n",
    "        self.ticks = self.ticks + 1\n",
    "        self.stm.start_timer('tock', 1000)\n",
    "\n",
    "    def on_tock(self):\n",
    "        print('Tock! {}'.format(self.tocks))\n",
    "        self.tocks = self.tocks + 1\n",
    "        self.stm.start_timer('tick', 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above you can see the three methods the state machine refers to. Within their body, they control simple counter variables `ticks` and `tocks`. The methods also start the timers `tick` and `tock`, with the method `self.stm.start_timer()`.\n",
    "\n",
    "We also need an instance of the Tick class for later:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tick = Tick()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's declare the state machine logic. We do so by creating Python dictionaries for each of the transitions above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# initial transition\n",
    "t0 = {'source': 'initial', \n",
    "      'target': 's_tick', \n",
    "      'effect':'on_init'\n",
    "     }\n",
    "\n",
    "# transition s_tick ----> s_tock\n",
    "t1 = {'trigger':'tick', \n",
    "      'source':'s_tick', \n",
    "      'target':'s_tock', \n",
    "      'effect':'on_tick'\n",
    "     }\n",
    "\n",
    "# transition s_tock ----> s_tick\n",
    "t2 = {'trigger':'tock', \n",
    "      'source':'s_tock', \n",
    "      'target':'s_tick', \n",
    "      'effect':'on_tock'\n",
    "     }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to import the Machine class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from stmpy import Machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we declare an instance for the machine, passing it the Tick object from above and the transitions. It also gets a name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tick_tock_machine = Machine(transitions=[t0, t1, t2], obj=tick, name='tick_tock')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to do one more technical thing. Above you see that the Tick class needs access to the `Machine` class so that it can start timers. For this, we use variable `stm` in the Tick class. We have to set the value of this variable now that we have created the corresponding machine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tick.stm = tick_tock_machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the state machine is declared and ready, we only have to run it. State machines are not executed directly, but assigned to a **Driver**. One driver corresponds to one thread and can execute many state machines at the same time. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from stmpy import Driver\n",
    "\n",
    "driver = Driver()\n",
    "\n",
    "# add our state machine to the driver\n",
    "driver.add_machine(tick_tock_machine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the driver is declared. What's left is to start it. Since this machine is describing an endless loop, we limit the number of transitions the driver executes to 5. You will see that the notebook cell is active until the driver stops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# start the driver, with limited number of transitions\n",
    "driver.start(max_transitions=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should now see that the state machine prints the following under the cell above:\n",
    "\n",
    "    Init!\n",
    "    Tick! 0\n",
    "    Tock! 0\n",
    "    Tick! 1\n",
    "    Tock! 1\n",
    "    \n",
    "You can also observe that the transitions are triggered by the timers, one every 1000 milliseconds."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Repetition\n",
    "\n",
    "- Transitions are declared as Python dictionaries.\n",
    "- Actions on transitions are declared in a special class for that state machine.\n",
    "- A `Machine` represents a state machine.\n",
    "- A `Driver` is needed to execute one (or several) state machines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}