j1-template 2022.5.0.rc3 → 2022.5.1.rc0

data/lib/starter_web/pages/public/_jupyter/notebooks/martin_renou_bqplot/Tutorials/Linking Plots With Widgets.ipynb

@@ -1,326 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Building interactive plots using `bqplot` and `ipywidgets`"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "* `bqplot` is built on top of the `ipywidgets` framework\n",
-    "* `ipwidgets` and `bqplot` widgets can be seamlessly integrated to build interactive plots\n",
-    "* `bqplot` figure widgets can be stacked with UI controls available in `ipywidgets` by using `Layout` classes (Box, HBox, VBox) in `ipywidgets`\n",
-    "(Note that *only* `Figure` objects (not `Mark` objects) inherit from `DOMWidget` class and can be combined with other widgets from `ipywidgets`)\n",
-    "* Trait attributes of widgets can be linked using callbacks. Callbacks should be registered using the `observe` method\n",
-    "\n",
-    "Please follow these links for detailed documentation on:\n",
-    "1. [Layout and Styling of Jupyter Widgets](https://ipywidgets.readthedocs.io/en/stable/examples/Widget%20Styling.html)\n",
-    "*  [Linking Widgets](https://ipywidgets.readthedocs.io/en/stable/examples/Widget%20Events.html)\n",
-    "\n",
-    "<br>Let's look at examples of linking plots with UI controls"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import ipywidgets as widgets\n",
-    "from ipywidgets import interact, Layout, IntSlider, FloatSlider"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import bqplot.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Update the plot on a button click"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d92dcdfef7254641a947a4f28e0fbe0e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(Figure(animation_duration=750, axes=[Axis(scale=LinearScale()), Axis(orientation='vertical', sc…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "y = np.random.randn(100).cumsum()  # simple random walk\n",
-    "\n",
-    "# create a button\n",
-    "update_btn = widgets.Button(description=\"Update\", button_style=\"success\")\n",
-    "\n",
-    "# create a figure widget\n",
-    "fig1 = plt.figure(animation_duration=750)\n",
-    "line = plt.plot(y)\n",
-    "\n",
-    "# define an on_click function\n",
-    "def on_btn_click(btn):\n",
-    "    # update the y attribute of line mark\n",
-    "    line.y = np.random.randn(100).cumsum()  # another random walk\n",
-    "\n",
-    "\n",
-    "# register the on_click function\n",
-    "update_btn.on_click(on_btn_click)\n",
-    "\n",
-    "# stack button and figure using VBox\n",
-    "widgets.VBox([fig1, update_btn])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's look at an example where we link a plot to a dropdown menu"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "\n",
-    "# create a dummy time series for 5 dummy stock tickers\n",
-    "dates = pd.date_range(start=\"20180101\", end=\"20181231\")\n",
-    "n = len(dates)\n",
-    "tickers = list(\"ABCDE\")\n",
-    "prices = pd.DataFrame(np.random.randn(n, 5).cumsum(axis=0), columns=tickers)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ebf6ff3b071249bd8168bc8f22232336",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(Dropdown(description='Ticker', options=('A', 'B', 'C', 'D', 'E'), value='A'), Figure(axes=[Axis…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# create a dropdown menu for tickers\n",
-    "dropdown = widgets.Dropdown(description=\"Ticker\", options=tickers)\n",
-    "\n",
-    "# create figure for plotting time series\n",
-    "current_ticker = dropdown.value\n",
-    "fig_title_tmpl = '\"{}\" Time Series'  # string template for title of the figure\n",
-    "fig2 = plt.figure(title=fig_title_tmpl.format(current_ticker))\n",
-    "fig2.layout.width = \"900px\"\n",
-    "time_series = plt.plot(dates, prices[current_ticker])\n",
-    "plt.xlabel(\"Date\")\n",
-    "plt.ylabel(\"Price\")\n",
-    "\n",
-    "# 1. create a callback which updates the plot when dropdown item is selected\n",
-    "def update_plot(*args):\n",
-    "    selected_ticker = dropdown.value\n",
-    "\n",
-    "    # update the y attribute of the mark by selecting\n",
-    "    # the column from the price data frame\n",
-    "    time_series.y = prices[selected_ticker]\n",
-    "\n",
-    "    # update the title of the figure\n",
-    "    fig2.title = fig_title_tmpl.format(selected_ticker)\n",
-    "\n",
-    "\n",
-    "# 2. register the callback by using the 'observe' method\n",
-    "dropdown.observe(update_plot, \"value\")\n",
-    "\n",
-    "# stack the dropdown and fig widgets using VBox\n",
-    "widgets.VBox([dropdown, fig2])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's now create a scatter plot where we select X and Y data from the two dropdown menus"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "38e7e130765f4822b773bcc6647812ec",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(HBox(children=(Dropdown(description='X', options=('A', 'B', 'C', 'D', 'E'), value='A'), Dropdow…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# create two dropdown menus for X and Y attributes of scatter\n",
-    "x_dropdown = widgets.Dropdown(description=\"X\", options=tickers, value=\"A\")\n",
-    "y_dropdown = widgets.Dropdown(description=\"Y\", options=tickers, value=\"B\")\n",
-    "\n",
-    "# create figure for plotting the scatter\n",
-    "x_ticker = x_dropdown.value\n",
-    "y_ticker = y_dropdown.value\n",
-    "\n",
-    "# set up fig_margin to allow space to display color bar\n",
-    "fig_margin = dict(top=20, bottom=40, left=60, right=80)\n",
-    "fig3 = plt.figure(animation_duration=1000, fig_margin=fig_margin)\n",
-    "\n",
-    "# custom axis options for color data\n",
-    "axes_options = {\"color\": {\"tick_format\": \"%m/%y\", \"side\": \"right\", \"num_ticks\": 5}}\n",
-    "scatter = plt.scatter(\n",
-    "    x=prices[x_ticker],\n",
-    "    y=prices[y_ticker],\n",
-    "    color=dates,  # represent chronology using color scale\n",
-    "    stroke=\"black\",\n",
-    "    colors=[\"red\"],\n",
-    "    default_size=32,\n",
-    "    axes_options=axes_options,\n",
-    ")\n",
-    "plt.xlabel(x_ticker)\n",
-    "plt.ylabel(y_ticker)\n",
-    "\n",
-    "# 1. create a callback which updates the plot when dropdown item is selected\n",
-    "def update_scatter(*args):\n",
-    "    x_ticker = x_dropdown.value\n",
-    "    y_ticker = y_dropdown.value\n",
-    "\n",
-    "    # update the x and y attributes of the mark by selecting\n",
-    "    # the column from the price data frame\n",
-    "    with scatter.hold_sync():\n",
-    "        scatter.x = prices[x_ticker]\n",
-    "        scatter.y = prices[y_ticker]\n",
-    "\n",
-    "    # update the title of the figure\n",
-    "    plt.xlabel(x_ticker)\n",
-    "    plt.ylabel(y_ticker)\n",
-    "\n",
-    "\n",
-    "# 2. register the callback by using the 'observe' method\n",
-    "x_dropdown.observe(update_scatter, \"value\")\n",
-    "y_dropdown.observe(update_scatter, \"value\")\n",
-    "\n",
-    "# stack the dropdown and fig widgets using VBox\n",
-    "widgets.VBox([widgets.HBox([x_dropdown, y_dropdown]), fig3])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In the example below, we'll look at plots of trigonometic functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "20ea9071584c4070a317e5b47fcce374",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "VBox(children=(Dropdown(description='Function', options={'sin': <ufunc 'sin'>, 'cos': <ufunc 'cos'>, 'tan': <u…"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "funcs = dict(sin=np.sin, cos=np.cos, tan=np.tan, sinh=np.sinh, tanh=np.tanh)\n",
-    "dropdown = widgets.Dropdown(options=funcs, description=\"Function\")\n",
-    "\n",
-    "fig = plt.figure(title=\"sin(x)\", animation_duration=1000)\n",
-    "\n",
-    "# create x and y data attributes for the line chart\n",
-    "x = np.arange(-10, 10, 0.1)\n",
-    "y = np.sin(x)\n",
-    "\n",
-    "line = plt.plot(x, y, \"m\")\n",
-    "\n",
-    "\n",
-    "def update_line(*args):\n",
-    "    f = dropdown.value\n",
-    "    fig.title = f\"{f.__name__}(x)\"\n",
-    "    line.y = f(line.x)\n",
-    "\n",
-    "\n",
-    "dropdown.observe(update_line, \"value\")\n",
-    "\n",
-    "widgets.VBox([dropdown, fig])"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

data/lib/starter_web/pages/public/_jupyter/notebooks/martin_renou_bqplot/Tutorials/Object Model.ipynb

@@ -1,179 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Object Model"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`bqplot` is based on **Grammar of Graphics** paradigm. The *Object Model* in `bqplot` gives the user the full flexibility to build custom plots. This means the API is verbose but fully customizable.\n",
-    "\n",
-    "The following are the steps to build a `Figure` in `bqplot` using the Object Model:\n",
-    "\n",
-    "* Build the scales for `x` and `y` quantities using the `Scale` classes (Scales map the data into pixels in the figure)\n",
-    "* Build the marks using the `Mark` classes. Marks represent the core plotting objects (lines, scatter, bars, pies etc.). Marks take the scale objects created in step 1 as arguments\n",
-    "* Build the `axes` for `x` and `y` scales\n",
-    "* Finally create a figure using `Figure` class. `Figure` takes marks and axes as inputs. `Figure` object is a widget (it inherits from `DOMWidget`) and can be rendered like any other jupyter widget\n",
-    "\n",
-    "Let's look a simple example to understand these concepts:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from bqplot import (\n",
-    "    LinearScale,\n",
-    "    Axis,\n",
-    "    Figure,\n",
-    "    OrdinalScale,\n",
-    "    LinearScale,\n",
-    "    Bars,\n",
-    "    Lines,\n",
-    "    Scatter,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y to plot using a Lines mark\n",
-    "import numpy as np\n",
-    "\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = np.sin(x)\n",
-    "\n",
-    "# 1. Create the scales\n",
-    "xs = LinearScale()\n",
-    "ys = LinearScale()\n",
-    "\n",
-    "# 2. Create the axes for x and y\n",
-    "xax = Axis(scale=xs, label=\"X\")\n",
-    "yax = Axis(scale=ys, orientation=\"vertical\", label=\"Y\")\n",
-    "\n",
-    "# 3. Create a Lines mark by passing in the scales\n",
-    "# note that Lines object is stored in `line` which can be used later to update the plot\n",
-    "line = Lines(x=x, y=y, scales={\"x\": xs, \"y\": ys})\n",
-    "\n",
-    "# 4. Create a Figure object by assembling marks and axes\n",
-    "fig = Figure(marks=[line], axes=[xax, yax], title=\"Simple Line Chart\")\n",
-    "\n",
-    "# 5. Render the figure using display or just as is\n",
-    "fig"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For creating other marks (like scatter, pie, bars, etc.), only step 3 needs to be changed. Lets look a simple example to create a bar chart:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y to plot a bar chart\n",
-    "x = list(\"ABCDE\")\n",
-    "y = np.random.rand(5)\n",
-    "\n",
-    "# 1. Create the scales\n",
-    "xs = OrdinalScale()  # note the use of ordinal scale to represent categorical data\n",
-    "ys = LinearScale()\n",
-    "\n",
-    "# 2. Create the axes for x and y\n",
-    "xax = Axis(scale=xs, label=\"X\", grid_lines=\"none\")  # no grid lines needed for x\n",
-    "yax = Axis(\n",
-    "    scale=ys, orientation=\"vertical\", label=\"Y\", tick_format=\".0%\"\n",
-    ")  # note the use of tick_format to format ticks\n",
-    "\n",
-    "# 3. Create a Bars mark by passing in the scales\n",
-    "# note that Bars object is stored in `bar` object which can be used later to update the plot\n",
-    "bar = Bars(x=x, y=y, scales={\"x\": xs, \"y\": ys}, padding=0.2)\n",
-    "\n",
-    "# 4. Create a Figure object by assembling marks and axes\n",
-    "Figure(marks=[bar], axes=[xax, yax], title=\"Simple Bar Chart\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Multiple marks can be rendered in a figure. It's as easy as passing a list of marks when constructing the `Figure` object"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y\n",
-    "import numpy as np\n",
-    "\n",
-    "x = np.linspace(-10, 10, 25)\n",
-    "y = 3 * x + 5\n",
-    "y_noise = y + 10 * np.random.randn(25)  # add some random noise to y\n",
-    "\n",
-    "# 1. Create the scales\n",
-    "xs = LinearScale()\n",
-    "ys = LinearScale()\n",
-    "\n",
-    "# 2. Create the axes for x and y\n",
-    "xax = Axis(scale=xs, label=\"X\")\n",
-    "yax = Axis(scale=ys, orientation=\"vertical\", label=\"Y\")\n",
-    "\n",
-    "# 3. Create a Lines and Scatter marks by passing in the scales\n",
-    "# additional attributes (stroke_width, colors etc.) can be passed as attributes to the mark objects as needed\n",
-    "line = Lines(x=x, y=y, scales={\"x\": xs, \"y\": ys}, colors=[\"green\"], stroke_width=3)\n",
-    "scatter = Scatter(\n",
-    "    x=x, y=y_noise, scales={\"x\": xs, \"y\": ys}, colors=[\"red\"], stroke=\"black\"\n",
-    ")\n",
-    "\n",
-    "# 4. Create a Figure object by assembling marks and axes\n",
-    "# pass both the marks (line and scatter) as a list to the marks attribute\n",
-    "Figure(marks=[line, scatter], axes=[xax, yax], title=\"Scatter and Line\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This introduction should be sufficient to get started with the *Object Model*. For detailed examples of rendering individual marks (with all their attributes) please look at the *Object Model* [examples](../Marks/Object Model)"
-   ]
-  }
- ],
- "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.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

data/lib/starter_web/pages/public/_jupyter/notebooks/martin_renou_bqplot/Tutorials/Pyplot.ipynb

@@ -1,174 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Pyplot"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`pyplot` is a context based functional API offering meaningful defaults. It's a concise API and very similar to matplotlib's pyplot. Users new to `bqplot` should use `pyplot` as a starting point. Users create figure and mark objects using `pyplot` functions.\n",
-    "\n",
-    "Steps for building plots in `pyplot`:\n",
-    "1. Create a figure object using plt.figure()\n",
-    "* (Optional steps)\n",
-    "    * Scales can be customized using `plt.scales` function\n",
-    "    * Axes options can customized by passing a dict to `axes_options` argument in the marks' functions\n",
-    "* Create marks using `pyplot` functions like `plot`, `bar`, `scatter` etc. (All the marks created will be automatically added to the figure object created in step 1)\n",
-    "* Render the figure object using the following approaches:\n",
-    "    * Using `plt.show` function which renders the figure in the current context along with toolbar for panzoom etc.\n",
-    "    * Using display on the figure object created in step 1 (toolbar doesn't show up in this case)\n",
-    "\n",
-    "`pyplot` also offers many helper functions. A few are listed here:\n",
-    "* plt.xlim: sets the domain bounds of the current 'x' scale\n",
-    "* plt.ylim: sets the domain bounds of the current 'y' scale\n",
-    "* plt.grids: shows/hides the axis grid lines\n",
-    "* plt.xlabel: sets the X-Axis label\n",
-    "* plt.ylabel: sets the Y-Axis label\n",
-    "* plt.hline: draws a horizontal line at a specified level\n",
-    "* plt.vline: draws a vertical line at a specified level\n",
-    "\n",
-    "Let's look at the same examples which were created in the [Object Model Notebook](Object Model.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import bqplot.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y to plot using a Lines mark\n",
-    "import numpy as np\n",
-    "\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = np.sin(x)\n",
-    "\n",
-    "# 1. Create the figure object\n",
-    "fig = plt.figure(title=\"Simple Line Chart\")\n",
-    "\n",
-    "# 2. By default axes are created with basic defaults. If you want to customize the axes create\n",
-    "# a dict and pass it to `axxes_options` argument in the marks\n",
-    "axes_opts = {\"x\": {\"label\": \"X\"}, \"y\": {\"label\": \"Y\"}}\n",
-    "\n",
-    "# 3. Create a Lines mark by calling plt.plot function\n",
-    "line = plt.plot(\n",
-    "    x=x, y=y, axes_options=axes_opts\n",
-    ")  # note that custom axes options are passed here\n",
-    "\n",
-    "# 4. Render the figure using plt.show()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For creating other marks (like scatter, pie, bars, etc.), only step 2 needs to be changed. Lets look a simple example to create a bar chart:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y to plot a bar chart\n",
-    "x = list(\"ABCDE\")\n",
-    "y = np.random.rand(5)\n",
-    "\n",
-    "# 1. Create the figure object\n",
-    "fig = plt.figure(title=\"Simple Bar Chart\")\n",
-    "\n",
-    "# 2. Customize the axes options\n",
-    "axes_opts = {\n",
-    "    \"x\": {\"label\": \"X\", \"grid_lines\": \"none\"},\n",
-    "    \"y\": {\"label\": \"Y\", \"tick_format\": \".0%\"},\n",
-    "}\n",
-    "\n",
-    "# 3. Create a Bars mark by calling plt.bar function\n",
-    "bar = plt.bar(x=x, y=y, padding=0.2, axes_options=axes_opts)\n",
-    "\n",
-    "# 4. directly display the figure object created in step 1 (note that the toolbar no longer shows up)\n",
-    "fig"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Multiple marks can be rendered in a figure. It's as easy as creating marks one after another. They'll all be added to the same figure!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# first, let's create two vectors x and y\n",
-    "import numpy as np\n",
-    "\n",
-    "x = np.linspace(-10, 10, 25)\n",
-    "y = 3 * x + 5\n",
-    "y_noise = y + 10 * np.random.randn(25)  # add some random noise to y\n",
-    "\n",
-    "# 1. Create the figure object\n",
-    "fig = plt.figure(title=\"Scatter and Line\")\n",
-    "\n",
-    "# 3. Create line and scatter marks\n",
-    "# additional attributes (stroke_width, colors etc.) can be passed as attributes to the mark objects as needed\n",
-    "line = plt.plot(x=x, y=y, colors=[\"green\"], stroke_width=3)\n",
-    "scatter = plt.scatter(x=x, y=y_noise, colors=[\"red\"], stroke=\"black\")\n",
-    "\n",
-    "# setting x and y axis labels using pyplot functions. Note that these functions\n",
-    "# should be called only after creating the marks\n",
-    "plt.xlabel(\"X\")\n",
-    "plt.ylabel(\"Y\")\n",
-    "\n",
-    "# 4. render the figure\n",
-    "fig"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "`pyplot` is a simpler and an intuitive API. It's available for all the marks except MarketMap. It should be used in almost all the cases by default since it offers a less verbose API compared to the Object Model. Please refer to the mark [examples](../Marks/Pyplot) using `pyplot` and also this [pyplot example](../Basic Plotting/Pyplot.ipynb) notebook"
-   ]
-  }
- ],
- "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.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}