10_webdev_talk.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Dealing with Async. Activity in the Jupyter Notebook**\n",
    "\n",
    "## About this presentation\n",
    "\n",
    "* Feedback on Jupyter as control platform for both machine and beamlines.\n",
    "* The following context is extracted from a POC (subproject of the SOLEIL \"BLISS\" project).\n",
    "* Focus on async. activity in the notebook.   \n",
    "\n",
    "## Initial motivation\n",
    "\n",
    "* Mixing CLI & GUI for machine and/or beamline controls?\n",
    "* The idea was to mix both CLI and GUI into a single environment in order to benefit from the best of both worlds.\n",
    "    * A pure CLI is convenient and powerful. But, provides no or very poor overview of the underlying systems state. \n",
    "    * With a GUI, no need to learn commands and options. However, GUIs are painful to maintain not so often ergonomic. \n",
    "* CLI & GUI complement each other. It consequently seems interesting to have both in a unique context.  \n",
    "\n",
    "## Why Jupyter?\n",
    "* Jupyter naturally solves a big part of the problem and its web nature provides remote access for free.\n",
    "\n",
    "## Main problems to be solved\n",
    "* Async. activity: how to refresh GUIs and plots in the background?\n",
    "* Cell specific outputs: how route outputs to a specific cell?\n",
    "* Large data handling: can we display large detector images?\n",
    "\n",
    "### Let's start with async. activity and cell specific outputs\n",
    "\n",
    "Jupyter async. features based on underlying the Tornado.IOLoop - who's a wrapper around the Python asyncio event loop.\n",
    "\n",
    "### `AsyncCallback`: a base class for async. callbacks relying on the tornado.ioloop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tornado.ioloop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AsyncCallback(object): \n",
    "    def __init__(self):\n",
    "        self.__cbc = 0\n",
    "        self.__pcb = tornado.ioloop.PeriodicCallback(self.__cbf, 1000.)\n",
    "\n",
    "    def start(self):\n",
    "        self.__pcb.start()\n",
    "        \n",
    "    def stop(self):\n",
    "        self.__pcb.stop()\n",
    "        \n",
    "    def is_running(self):\n",
    "        return self.__pcb.is_running()\n",
    "        \n",
    "    def set_callback_period(self, p):\n",
    "        p = max(0.1, p) \n",
    "        p = min(p, 1.0)\n",
    "        was_running =  self.__pcb.is_running()\n",
    "        self.__pcb.stop()\n",
    "        self.__pcb = tornado.ioloop.PeriodicCallback(self.__cbf, p * 1000.)\n",
    "        if was_running:\n",
    "            self.__pcb.start()\n",
    "\n",
    "    def __cbf(self):\n",
    "        self.__cbc += 1\n",
    "        self.cbf(self.__cbc)\n",
    "        \n",
    "    def cbf(self, cbc):\n",
    "        raise Exception(\"AsyncCallback: default callback impl. called!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `AsyncOutputV1`: an async. callback executing a simple print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AsyncOutputV1(AsyncCallback): \n",
    "    def __init__(self):\n",
    "        AsyncCallback.__init__(self)\n",
    "\n",
    "    def cbf(self, cbc):\n",
    "        print('AsyncOutputV1.cb-call #{:02d}'.format(cbc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao1 = AsyncOutputV1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao1.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another cell\n",
    "print(\"this is the 'current' cell!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another cell\n",
    "print(\"this is the 'current' cell!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao1.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `AsyncOutputV2`: an async. callback routing its outputs to a \"specific\" cell output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `CellOutput`\n",
    "A Python context providing a way to route outputs to a \"particular\" cell: the one that was the \"current cell\" when the CellOutput instance has been created.\n",
    "\n",
    "This is a ipython low level implementation based on a simple idea: snapshot the initial context at instanciation, then, when whe want to output something, simply save the current context, activate the initial one, output some content, then restore previous one. Here we use a Python context (and the 'with' keyword) implement the 'set/restore context' mechanism properly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CellOutput(object):\n",
    "    def __init__(self):\n",
    "        k = get_ipython().kernel\n",
    "        self._ident = k._parent_ident\n",
    "        self._header = k.get_parent()\n",
    "        self._save_context = None\n",
    "\n",
    "    def __enter__(self):\n",
    "        kernel = get_ipython().kernel\n",
    "        self._save_context = (kernel._parent_ident, kernel.get_parent())\n",
    "        sys.stdout.flush()\n",
    "        sys.stderr.flush()\n",
    "        kernel.set_parent(self._ident, self._header)\n",
    "\n",
    "    def __exit__(self, etype, evalue, tb):\n",
    "        sys.stdout.flush()\n",
    "        sys.stderr.flush()\n",
    "        kernel = get_ipython().kernel\n",
    "        kernel.set_parent(*self._save_context)\n",
    "        return False\n",
    "\n",
    "    def clear_output(self):\n",
    "        with self:\n",
    "            clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `AsyncOutputV2` impl."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AsyncOutputV2(AsyncCallback): \n",
    "    def __init__(self):\n",
    "        AsyncCallback.__init__(self)\n",
    "        self.__outpout = CellOutput()\n",
    "        \n",
    "    def cbf(self, cbc):\n",
    "        self.__outpout.clear_output()\n",
    "        with self.__outpout:\n",
    "            print('AsyncOutputV2.cb-call #{:02d}'.format(cbc))\n",
    "                \n",
    "    def clear_output(self):\n",
    "        self.__outpout.clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao2 = AsyncOutputV2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao2.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another cell\n",
    "print(\"this is the 'current' cell!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another cell\n",
    "print(\"this is the 'current' cell!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao2.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao2.clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `AsyncOutputV3`: an async. callback using (ipy)widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as ipw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AsyncOutputV3(AsyncCallback): \n",
    "    def __init__(self):\n",
    "        AsyncCallback.__init__(self)\n",
    "        self.__int_text = ipw.IntText(value=0, description='Call #', disabled=True)\n",
    "        self.__progress = ipw.IntProgress(value=0, min=0, max=99, description='Progress')\n",
    "        b = ipw.Button(tooltip='Start Async. Activity', icon='play', layout=ipw.Layout(height='auto', width='auto'))\n",
    "        b.on_click(self.__ctrl_button_clicked)\n",
    "        self.__cbp_slider = ipw.FloatSlider(value = 1.0, min=0.1, max=1.0, description='Period (in s):')\n",
    "        self.__cbp_slider.observe(self.__period_changed, names='value')\n",
    "        self.__hbox = ipw.HBox([b, self.__int_text, self.__progress, self.__cbp_slider])\n",
    "        display(self.__hbox)\n",
    "        \n",
    "    def __ctrl_button_clicked(self, b):\n",
    "        if not self.is_running():\n",
    "            self.start()\n",
    "            b.icon = 'stop'\n",
    "        else:\n",
    "            self.stop()\n",
    "            b.icon = 'play'\n",
    "            \n",
    "    def __period_changed(self, change):\n",
    "        self.set_callback_period(change['new'])\n",
    "        \n",
    "    def cbf(self, cbc):\n",
    "        self.__int_text.value = cbc % 100\n",
    "        self.__progress.value = cbc % 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao3 = AsyncOutputV3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ao4 = AsyncOutputV3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `IcePapController`: a motor controller for the Jupyter notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import tango\n",
    "\n",
    "class IcePapController(AsyncCallback):\n",
    "    \n",
    "    class IcePapWidgets(object):\n",
    "        def __init__(self, device, target_position):\n",
    "            self.actuator = tango.DeviceProxy(device)\n",
    "            current_position = self.actuator.Position\n",
    "            self.forward = target_position > current_position\n",
    "            children_layout = list()\n",
    "            self.unit = self.actuator.get_attribute_config('Position').unit\n",
    "            try:\n",
    "                self.alias = self.actuator.alias()\n",
    "            except:\n",
    "                self.alias = device\n",
    "            lbt = \"moving {} from {:.2f} to {:.2f} {} @ {:.2f} {}/s: \".format(self.alias,\n",
    "                                                                              current_position,\n",
    "                                                                              target_position,\n",
    "                                                                              self.unit,\n",
    "                                                                              self.actuator.Velocity,\n",
    "                                                                              self.unit)\n",
    "            lb = ipw.Label(value=lbt)\n",
    "            self.slb = ipw.Label(value=\" [{}]\".format(self.actuator.state()), layout=self.l11a())\n",
    "            children_layout.append(ipw.HBox([lb, self.slb]))\n",
    "            widgets = list()\n",
    "            self.bls = ipw.Checkbox(value=self.actuator.HardLimitHigh,\n",
    "                                    description='bls',\n",
    "                                    indent=False,\n",
    "                                    layout=self.l01a())\n",
    "            self.bls.observe(self.on_cb_clicked, names='value')\n",
    "            widgets.append(self.bls)\n",
    "            will_move = abs(current_position - target_position) > 0.\n",
    "            if will_move:\n",
    "              self.pgb = ipw.FloatProgress(value=current_position if self.forward else target_position,\n",
    "                                           min=min(current_position, target_position),\n",
    "                                           max=max(current_position, target_position))\n",
    "            else:\n",
    "              self.pgb = ipw.FloatProgress(value=100,\n",
    "                                           min=0,\n",
    "                                           max=100)    \n",
    "            self.pgb.style.bar_color = self.device_state_to_widget_color(self.actuator.state())                      \n",
    "            widgets.append(self.pgb)\n",
    "            self.fls = ipw.Checkbox(value=self.actuator.HardLimitLow,\n",
    "                                    description='fls',\n",
    "                                    indent=False,\n",
    "                                    layout=self.l01a())\n",
    "            self.fls.observe(self.on_cb_clicked, names='value')\n",
    "            widgets.append(self.fls)\n",
    "            lb = ipw.Label(value='', layout=self.l01a(width='30px'))\n",
    "            widgets.append(lb)\n",
    "            lbt = \" {:.2f} {}\".format(current_position, self.unit)\n",
    "            self.plb = ipw.Label(value=lbt, layout=self.l01a())\n",
    "            widgets.append(self.plb)\n",
    "            lb = ipw.Label(value='', layout=self.l01a(width='30px'))\n",
    "            widgets.append(lb)\n",
    "            b = ipw.Button(tooltip='Abort Motion', icon='stop', layout=ipw.Layout(height='auto', width='auto'))\n",
    "            b.on_click(self.abort)\n",
    "            widgets.append(b)\n",
    "            self.status_widgets = ipw.HBox(widgets)\n",
    "            children_layout.append(self.status_widgets)\n",
    "            self.layout = ipw.VBox(children_layout, layout=self.l01a())\n",
    "\n",
    "        def on_cb_clicked(self, change):\n",
    "            self.update_limit_switches()\n",
    "\n",
    "        def get_pos_and_state(self):\n",
    "            try:\n",
    "                current_position = self.actuator.Position\n",
    "                current_state = self.actuator.state()\n",
    "            except:\n",
    "                current_position = float('nan')\n",
    "                current_state = Tango.DevState.UNKNOWN\n",
    "            return current_position, current_state\n",
    "\n",
    "        def update_progress_bar(self, current_position, current_state, motion_done=False):\n",
    "            if motion_done:\n",
    "                bad_states = [tango.DevState.UNKNOWN, tango.DevState.FAULT]\n",
    "                self.pgb.value = current_position if current_state in bad_states else self.pgb.max\n",
    "            else:\n",
    "                self.pgb.value = current_position\n",
    "            self.pgb.style.bar_color = self.device_state_to_widget_color(current_state)\n",
    "\n",
    "        def update_limit_switches(self):\n",
    "            self.bls.value = self.actuator.HardLimitLow\n",
    "            self.fls.value = self.actuator.HardLimitHigh\n",
    "\n",
    "        def update_state(self, current_state):\n",
    "            self.slb.value = \"[{}]\".format(str(current_state))\n",
    "\n",
    "        def update(self, aborted=False):\n",
    "            motion_done = self.actuator.state() != tango.DevState.MOVING\n",
    "            current_position, current_state = self.get_pos_and_state()\n",
    "            self.update_progress_bar(current_position, current_state, motion_done)\n",
    "            self.update_limit_switches()\n",
    "            self.update_state(current_state)\n",
    "            if motion_done:\n",
    "                plb_value = \"\\t{}[{} is @ {:.2f} {}]\".format('*** ABORTED ***\\t' if aborted else '',\n",
    "                                                             self.alias,\n",
    "                                                             current_position,\n",
    "                                                             self.unit)\n",
    "            else:\n",
    "                plb_value = \"\\t{:.2f} {}\".format(current_position, self.unit)\n",
    "            self.plb.value = plb_value\n",
    "\n",
    "        def abort(self, b=None):\n",
    "            self.actuator.Abort()\n",
    "            self.update(aborted=True)\n",
    "            \n",
    "        def l01a(cls, width='auto', *args, **kwargs):\n",
    "            return ipw.Layout(flex='0 1 auto', width=width, *args, **kwargs)\n",
    "            \n",
    "        def l11a(cls, width='auto', *args, **kwargs):\n",
    "            return ipw.Layout(flex='1 1 auto', width=width, *args, **kwargs)\n",
    "    \n",
    "        def device_state_to_widget_style(cls, s):\n",
    "            if s in [tango.DevState.STANDBY, tango.DevState.ON]:\n",
    "                return 'warning'\n",
    "            if s in [tango.DevState.RUNNING]:\n",
    "                return 'success'\n",
    "            if s in [tango.DevState.MOVING]:\n",
    "                return 'primary'\n",
    "            if s in [tango.DevState.FAULT, tango.DevState.UNKNOWN]:\n",
    "                return 'danger'\n",
    "            if s in [tango.DevState.ALARM]:\n",
    "                return 'danger'\n",
    "            return ''\n",
    "\n",
    "        def device_state_to_widget_color(cls, s):\n",
    "            if s in [tango.DevState.INIT]:\n",
    "                return '#CCCC7A'\n",
    "            if s in [tango.DevState.STANDBY]:\n",
    "                return '#FFFF00'\n",
    "            if s in [tango.DevState.ON, tango.DevState.OPEN, tango.DevState.EXTRACT]:\n",
    "                return '#00FF00'\n",
    "            if s in [tango.DevState.OFF, tango.DevState.CLOSE, tango.DevState.INSERT]:\n",
    "                return '#FFFFFF'\n",
    "            if s in [tango.DevState.MOVING]:\n",
    "                return '#80A0FF'\n",
    "            if s in [tango.DevState.RUNNING]:\n",
    "                return '#228B22'\n",
    "            if s in [tango.DevState.FAULT]:\n",
    "                return '#FF0000'\n",
    "            if s in [tango.DevState.UNKNOWN]:\n",
    "                return '#808080'\n",
    "            if s in [tango.DevState.ALARM]:\n",
    "                return '#FF8C00'\n",
    "            if s in [tango.DevState.DISABLE]:\n",
    "                return '#FF00FF'\n",
    "            return '#808080'\n",
    "\n",
    "    def __init__(self):\n",
    "        AsyncCallback.__init__(self)\n",
    "        self.layout = None\n",
    "        self.actuator_widgets = None\n",
    "\n",
    "    def __update_widgets(self, aborted=False):\n",
    "        for w in self.actuator_widgets.values():\n",
    "            w.update(aborted)\n",
    "            \n",
    "    def goto(self, move_requests):\n",
    "        \"\"\"requests: {actuator1:position1, actuator2:position2, ...}\"\"\"\n",
    "        # setup widgets for each actuator\n",
    "        self.actuator_widgets = {k: IcePapController.IcePapWidgets(k, v) for k, v in move_requests.items()}\n",
    "        b = ipw.Button(tooltip='Abort motions', icon='stop', layout=ipw.Layout(height='auto', width='auto'))\n",
    "        b.on_click(self.abort)\n",
    "        widgets = [v.layout for _, v in self.actuator_widgets.items()]\n",
    "        #widgets.append(b)\n",
    "        self.layout = ipw.VBox(widgets)\n",
    "        display(self.layout)\n",
    "        self.start()        \n",
    "        for k, v in move_requests.items():\n",
    "            tango.DeviceProxy(k).Position = v\n",
    "\n",
    "    def abort(self, b=None):\n",
    "        self.stop()\n",
    "        for w in self.actuator_widgets.values():\n",
    "            w.abort()\n",
    "            \n",
    "    def cbf(self, cbc):\n",
    "        self.__update_widgets()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ipc = IcePapController()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ipc.goto({\"m1\":100, \"m2\":200})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A `SPEC` like CLI for the `IcePapController` based on the `IPython magics`\n",
    "\n",
    "Define 'amove' magic with the following syntax: **amove motor-name target-position** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.magic import Magics, magics_class, line_magic\n",
    "from IPython.core.magic_arguments import argument, magic_arguments, parse_argstring\n",
    "\n",
    "@magics_class\n",
    "class MyMagics(Magics):\n",
    "\n",
    "    @magic_arguments()\n",
    "    @argument('movable', help='fully specified movable name or alias')\n",
    "    @argument('position', help='target position')\n",
    "    @line_magic\n",
    "    def mv(self, line):\n",
    "        ns = parse_argstring(self.mv, line)\n",
    "        ipc = IcePapController()\n",
    "        ipc.goto({ns.movable:float(ns.position)})\n",
    "        \n",
    "get_ipython().register_magics(MyMagics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mv m1 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## jupyter for DAQ configuration, control and monitoring\n",
    "Dynamic interface based on introspection of the scan configuration. \n",
    "\n",
    "* **scan parameters**\n",
    "<img src=\"./tango_meeting_florence_0617/resources/images/fs_gui_params.png\">\n",
    "* **sensors selection**\n",
    "<img src=\"./tango_meeting_florence_0617/resources/images/fs_gui_sensors.png\">\n",
    "* **scan actors monitoring**\n",
    "<img src=\"./tango_meeting_florence_0617/resources/images/fs_gui_devices_monitoring.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# **The `jupyTango` environment**\n",
    "\n",
    "jupyTango defines two jupyter magics (more to come): `%tango_monitor` and `%plot_tango_attribute`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The`%plot_tango_attribute` (or `%pta`) generates a static/synchronous plot of any tango attribute (snapshot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ugly but mandatory: select the context in which we are running: NOTEBOOK or LAB\n",
    "import os\n",
    "os.environ[\"JUPYTER_CONTEXT\"] = \"LAB\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `%tango_monitor` - or its alias `%tgm` - provides us with a live/asynchronous monitor for any tango attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tgm sys/tg_test/nl1/double_image_ro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tgm -w 1200 sys/tg_test/nl1/double_scalar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mix. a Tango monitor with an IcePapController"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tgm -w 1200 -p 0.25 m1/Position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mv m1 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "tango.DeviceProxy(\"m1\").Velocity = 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!which python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupyTango",
   "language": "python",
   "name": "jupytango"
  },
  "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}