pokemon-pipeline/pokemon-pipeline/pokemon-pipeline.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pokemon pipeline\n",
    "\n",
    "Note: This notebook runs on Python 3.9 and uses UbiOps CLient Library 3.15.0.\n",
    "\n",
    "If you run this entire notebook after filling in your access token, the pipeline and all the necessary models will be deployed to your UbiOps environment. You can thus check your environment after running to explore. You can also check the individual steps in this notebook to see what we did exactly and how you can adapt it to your own use case.\n",
    "\n",
    "We recommend to run the cells step by step, as some cells can take a few minutes to finish.\n",
    "\n",
    "## Establishing a connection with your UbiOps environment\n",
    "Add your API token. Then we will provide a project name, deployment name and deployment version name. Afterwards we initialize the client library. This way we can deploy the two pipelines to your environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "API_TOKEN = '<INSERT API_TOKEN WITH PROJECT EDITOR RIGHTS>'\n",
    "PROJECT_NAME= '<INSERT PROJECT NAME IN YOUR ACCOUNT>'\n",
    "DEPLOYMENT_VERSION='v1'\n",
    "\n",
    "import ubiops\n",
    "import shutil\n",
    "import os\n",
    "\n",
    "client = ubiops.ApiClient(ubiops.Configuration(api_key={'Authorization': API_TOKEN}, \n",
    "                                               host='https://api.ubiops.com/v2.1'))\n",
    "api = ubiops.CoreApi(client)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize local repositories "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.mkdir(\"pokemon_matcher\")\n",
    "os.mkdir(\"pokemon_sorter\")\n",
    "os.mkdir(\"pokemon_vis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the deployments\n",
    "\n",
    "\n",
    "\n",
    "### Pokemon matcher\n",
    "I found a [dataset on Kaggle](https://kaggle.com/abcsds/pokemon) that has statistics for every Pokémon, which we can use to match names to statistics. When dealing with customers instead of Pokémon this would be replaced by for example your CRM.\n",
    "\n",
    "In this deployment we do the following steps: \n",
    "- Read the input Pokémon\n",
    "- Read our file with all the Pokémon stats\n",
    "- Select only the Pokémon we got as input\n",
    "- Export this selection to a CSV file\n",
    "\n",
    "See the actual code in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_matcher/deployment.py\n",
    "import pandas as pd\n",
    "import requests\n",
    "\"\"\"\n",
    "The file containing the deployment code is required to be called 'deployment.py' and should contain the 'Deployment'\n",
    "class and 'request' method.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class Deployment:\n",
    "\n",
    "    def __init__(self, base_directory, context):\n",
    "        \"\"\"\n",
    "        Initialisation method for the deployment. It can for example be used for loading modules that have to be kept in\n",
    "        memory or setting up connections. Load your external model files (such as pickles or .h5 files) here.\n",
    "        \"\"\"\n",
    "\n",
    "        print(\"Initialising My Deployment\")\n",
    "\n",
    "\n",
    "    def request(self, data):\n",
    "        \"\"\"\n",
    "        Method for deployment requests, called separately for each individual request.\n",
    "        with plain output, it is a string. In this example, a dictionary with the key: output.\n",
    "        \"\"\"\n",
    "\n",
    "        selected_pokemon = data.get('input_pokemon')\n",
    "\n",
    "        pokemon_stats = pd.read_csv(\"https://storage.googleapis.com/ubiops/data/Working%20with%20pipelines/pokemon-pipeline/Pokemon.csv\")\n",
    "\n",
    "        selected_pokemon_stats = pokemon_stats.loc[pokemon_stats['Name'].isin(selected_pokemon)]\n",
    "\n",
    "        selected_pokemon_stats.to_csv('selected_pokemon_stats.csv')\n",
    "\n",
    "        return {\n",
    "            \"output_pokemon\": 'selected_pokemon_stats.csv'\n",
    "        }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_matcher/requirements.txt\n",
    "\n",
    "pandas == 1.4.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we create a deployment and a deployment version for the package in the cell above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zip the models\n",
    "shutil.make_archive('pokemon_matcher', 'zip', '.','pokemon_matcher')\n",
    "\n",
    "deployment_template = ubiops.DeploymentCreate(\n",
    "    name='pokemon-matcher',\n",
    "    description='Match pokemon names to their stats',\n",
    "    input_type='structured',\n",
    "    output_type='structured',\n",
    "    input_fields=[\n",
    "        {'name':'input_pokemon', 'data_type':'array_string'}\n",
    "    ],\n",
    "    output_fields=[\n",
    "        {'name':'output_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    labels={'demo': 'pokemon-pipeline'}\n",
    ")\n",
    "\n",
    "api.deployments_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    data=deployment_template\n",
    ")\n",
    "\n",
    "# Create the version\n",
    "version_template = ubiops.DeploymentVersionCreate(\n",
    "    version='v1',\n",
    "    environment='python3-9',\n",
    "    instance_type='512mb',\n",
    "    minimum_instances=0,\n",
    "    maximum_instances=1,\n",
    "    maximum_idle_time=1800, # = 30 minutes\n",
    "    request_retention_mode='none' # We don't need to store the requests for this deployment\n",
    ")\n",
    "\n",
    "api.deployment_versions_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-matcher',\n",
    "    data=version_template\n",
    ")\n",
    "\n",
    "# Upload the zipped deployment package\n",
    "upload_response1 = api.revisions_file_upload(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-matcher',\n",
    "    version='v1',\n",
    "    file='pokemon_matcher.zip'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pokemon sorter\n",
    "We need to sort these Pokémon based on the best stats, we can start with the CSV from the Pokémon matcher step.\n",
    "\n",
    "In this deployment we perform the following steps: \n",
    "- Read the input CSV(from the matcher step)\n",
    "- Sort them based on their stats(higher is better)\n",
    "- Export this as a CSV file\n",
    "\n",
    "See the actual code in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_sorter/deployment.py\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "\"\"\"\n",
    "The file containing the deployment code is required to be called 'deployment.py' and should contain the 'Deployment'\n",
    "class and 'request' method.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class Deployment:\n",
    "\n",
    "    def __init__(self, base_directory, context):\n",
    "        \"\"\"\n",
    "        Initialisation method for the deployment. It can for example be used for loading modules that have to be kept in\n",
    "        memory or setting up connections. Load your external model files (such as pickles or .h5 files) here.\n",
    "        \"\"\"\n",
    "\n",
    "        print(\"Initialising My Deployment\")\n",
    "\n",
    "    def request(self, data):\n",
    "        \"\"\"\n",
    "        Method for deployment requests, called separately for each individual request.\n",
    "        \"\"\"\n",
    "\n",
    "        pokemon_stats = pd.read_csv(data.get('input_pokemon'))\n",
    "\n",
    "        sorted_pokemon_stats = pokemon_stats.sort_values([\"HP\", \"Attack\", \"Defense\", \"Sp. Atk\", \"Sp. Def\", \"Speed\"])\n",
    "\n",
    "        sorted_pokemon_stats.to_csv('sorted_pokemon_stats.csv')\n",
    "\n",
    "        return {\n",
    "            \"output_pokemon\": 'sorted_pokemon_stats.csv'\n",
    "        }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_sorter/requirements.txt\n",
    "\n",
    "pandas == 1.4.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we create a deployment and a deployment version for the package in the cell above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zip the models\n",
    "shutil.make_archive('pokemon_sorter', 'zip', '.','pokemon_sorter')\n",
    "\n",
    "deployment_template = ubiops.DeploymentCreate(\n",
    "    name='pokemon-sorter',\n",
    "    description='Sort pokemon based on their stats',\n",
    "    input_type='structured',\n",
    "    output_type='structured',\n",
    "    input_fields=[\n",
    "        {'name':'input_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    output_fields=[\n",
    "        {'name':'output_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    labels={'demo': 'pokemon-pipeline'}\n",
    ")\n",
    "\n",
    "api.deployments_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    data=deployment_template\n",
    ")\n",
    "\n",
    "# Create the version\n",
    "version_template = ubiops.DeploymentVersionCreate(\n",
    "    version='v1',\n",
    "    environment='python3-9',\n",
    "    instance_type='512mb',\n",
    "    minimum_instances=0,\n",
    "    maximum_instances=1,\n",
    "    maximum_idle_time=1800, # = 30 minutes\n",
    "    request_retention_mode='none' # We don't need to store the requests for this deployment\n",
    ")\n",
    "\n",
    "api.deployment_versions_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-sorter',\n",
    "    data=version_template\n",
    ")\n",
    "\n",
    "# Upload the zipped deployment package\n",
    "upload_response2 = api.revisions_file_upload(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-sorter',\n",
    "    version='v1',\n",
    "    file='pokemon_sorter.zip'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pokemon visualizer\n",
    "I found a great [code snippet](https://kaggle.com/wenxuanchen/pokemon-visualization-radar-chart-t-sne) online for creating Pokémon stat visualizations, just like I remember seeing them on my old “Gameboy color”.\n",
    "\n",
    "It is not really important to understand what’s happening in this visualization code, just that we can visualize the Pokémon we got from our previous step. The visualisation is then outputted as a PDF.\n",
    "\n",
    "See the actual code in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_vis/deployment.py\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\"\"\"\n",
    "The file containing the deployment code is required to be called 'deployment.py' and should contain the 'Deployment'\n",
    "class and 'request' method.\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "class Deployment:\n",
    "\n",
    "    def __init__(self, base_directory, context):\n",
    "        \"\"\"\n",
    "        Initialisation method for the deployment. It can for example be used for loading modules that have to be kept in\n",
    "        memory or setting up connections. Load your external model files (such as pickles or .h5 files) here.\n",
    "        \"\"\"\n",
    "\n",
    "        print(\"Initialising My Deployment\")\n",
    "\n",
    "    def request(self, data):\n",
    "        \"\"\"\n",
    "        Method for deployment requests, called separately for each individual request.\n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "        # In this order,\n",
    "        # HP, Defense and Sp. Def will show on left; They represent defense abilities\n",
    "        # Speed, Attack and Sp. Atk will show on right; They represent attack abilities\n",
    "        # Attack and Defense, Sp. Atk and Sp. Def will show on opposite positions\n",
    "        use_attributes = ['Speed', 'Sp. Atk', 'Defense', 'HP', 'Sp. Def', 'Attack']\n",
    "\n",
    "        pokemon = pd.read_csv(data.get(\"input_pokemon\"))\n",
    "        df_plot = pokemon\n",
    "\n",
    "        datas = df_plot[use_attributes].values\n",
    "        ranges = [[2 ** -20, df_plot[attr].max()] for attr in use_attributes]\n",
    "        colors = select_color(df_plot['Type 1'])  # select colors based on pokemon Type 1\n",
    "\n",
    "        fig = plt.figure(figsize=(10, 10))\n",
    "        radar = RaderChart(fig, use_attributes, ranges)\n",
    "        for data, color, pokemon in zip(datas, colors, pokemon['Name'].tolist()):\n",
    "            radar.plot(data, color=color, label=pokemon)\n",
    "            radar.fill(data, alpha=0.1, color=color)\n",
    "            radar.legend(loc=1, fontsize='small')\n",
    "        plt.savefig('pokemon.pdf')\n",
    "\n",
    "        return {\n",
    "            \"output_pokemon\": 'pokemon.pdf'\n",
    "        }\n",
    "\n",
    "\n",
    "def _scale_data(data, ranges):\n",
    "    (x1, x2), d = ranges[0], data[0]\n",
    "    return [(d - y1) / (y2 - y1) * (x2 - x1) + x1 for d, (y1, y2) in zip(data, ranges)]\n",
    "\n",
    "\n",
    "class RaderChart():\n",
    "    def __init__(self, fig, variables, ranges, n_ordinate_levels=6):\n",
    "        angles = np.arange(0, 360, 360. / len(variables))\n",
    "\n",
    "        axes = [fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True, label=\"axes{}\".format(i)) for i in\n",
    "                range(len(variables))]\n",
    "        _, text = axes[0].set_thetagrids(angles, labels=variables)\n",
    "\n",
    "        for txt, angle in zip(text, angles):\n",
    "            txt.set_rotation(angle - 90)\n",
    "\n",
    "        for ax in axes[1:]:\n",
    "            ax.patch.set_visible(False)\n",
    "            ax.xaxis.set_visible(False)\n",
    "            ax.grid(\"off\")\n",
    "\n",
    "        for i, ax in enumerate(axes):\n",
    "            grid = np.linspace(*ranges[i], num=n_ordinate_levels)\n",
    "            grid_label = [\"\"] + [str(int(x)) for x in grid[1:]]\n",
    "            ax.set_rgrids(grid, labels=grid_label, angle=angles[i])\n",
    "            ax.set_ylim(*ranges[i])\n",
    "\n",
    "        self.angle = np.deg2rad(np.r_[angles, angles[0]])\n",
    "        self.ranges = ranges\n",
    "        self.ax = axes[0]\n",
    "\n",
    "    def plot(self, data, *args, **kw):\n",
    "        sdata = _scale_data(data, self.ranges)\n",
    "        self.ax.plot(self.angle, np.r_[sdata, sdata[0]], *args, **kw)\n",
    "\n",
    "    def fill(self, data, *args, **kw):\n",
    "        sdata = _scale_data(data, self.ranges)\n",
    "        self.ax.fill(self.angle, np.r_[sdata, sdata[0]], *args, **kw)\n",
    "\n",
    "    def legend(self, *args, **kw):\n",
    "        self.ax.legend(*args, **kw)\n",
    "\n",
    "\n",
    "TYPE_LIST = ['Grass', 'Fire', 'Water', 'Bug', 'Normal', 'Poison',\n",
    "             'Electric', 'Ground', 'Fairy', 'Fighting', 'Psychic',\n",
    "             'Rock', 'Ghost', 'Ice', 'Dragon', 'Dark', 'Steel', 'Flying']\n",
    "\n",
    "COLOR_LIST = ['#8ED752', '#F95643', '#53AFFE', '#C3D221', '#BBBDAF', '#AD5CA2',\n",
    "              '#F8E64E', '#F0CA42', '#F9AEFE', '#A35449', '#FB61B4', '#CDBD72',\n",
    "              '#7673DA', '#66EBFF', '#8B76FF', '#8E6856', '#C3C1D7', '#75A4F9']\n",
    "\n",
    "# The colors are copied from this script: https://kaggle.com/ndrewgele/d/abcsds/pokemon/visualizing-pok-mon-stats-with-seaborn\n",
    "# The colors look reasonable in this map: For example, Green for Grass, Red for Fire, Blue for Water...\n",
    "COLOR_MAP = dict(zip(TYPE_LIST, COLOR_LIST))\n",
    "\n",
    "\n",
    "# select display colors according to Pokemon's Type 1\n",
    "def select_color(types):\n",
    "    colors = [None] * len(types)\n",
    "    used_colors = set()\n",
    "    for i, t in enumerate(types):\n",
    "        curr = COLOR_MAP[t]\n",
    "        if curr not in used_colors:\n",
    "            colors[i] = curr\n",
    "            used_colors.add(curr)\n",
    "    unused_colors = set(COLOR_LIST) - used_colors\n",
    "    for i, c in enumerate(colors):\n",
    "        if not c:\n",
    "            try:\n",
    "                colors[i] = unused_colors.pop()\n",
    "            except:\n",
    "                raise Exception('Attempt to visualize too many pokemon. No more colors available.')\n",
    "    return colors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile pokemon_vis/requirements.txt\n",
    "\n",
    "pandas == 1.4.2\n",
    "seaborn == 0.12.1\n",
    "matplotlib == 3.5.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we create a deployment and a deployment version for the package in the cell above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zip the models\n",
    "shutil.make_archive('pokemon_vis', 'zip', '.','pokemon_vis')\n",
    "\n",
    "deployment_template = ubiops.DeploymentCreate(\n",
    "    name='pokemon-vis',\n",
    "    description='Visualize the results.',\n",
    "    input_type='structured',\n",
    "    output_type='structured',\n",
    "    input_fields=[\n",
    "        {'name':'input_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    output_fields=[\n",
    "        {'name':'output_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    labels={'demo': 'pokemon-pipeline'}\n",
    ")\n",
    "\n",
    "api.deployments_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    data=deployment_template\n",
    ")\n",
    "\n",
    "# Create the version\n",
    "version_template = ubiops.DeploymentVersionCreate(\n",
    "    version='v1',\n",
    "    environment='python3-9',\n",
    "    instance_type='512mb',\n",
    "    minimum_instances=0,\n",
    "    maximum_instances=1,\n",
    "    maximum_idle_time=1800, # = 30 minutes\n",
    "    request_retention_mode='none' # We don't need to store the requests for this deployment\n",
    ")\n",
    "\n",
    "api.deployment_versions_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-vis',\n",
    "    data=version_template\n",
    ")\n",
    "\n",
    "# Upload the zipped deployment package\n",
    "upload_response3 = api.revisions_file_upload(\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-vis',\n",
    "    version='v1',\n",
    "    file='pokemon_vis.zip'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the Pokemon pipeline\n",
    "\n",
    "So right now we have three deployments. We want to tie these blocks together. We can use pipelines for that. Let's create a pipeline that takes the same input as the pokemon_sorter deployment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_name = \"pokemon-pipeline\"\n",
    "PIPELINE_VERSION = DEPLOYMENT_VERSION\n",
    "\n",
    "pipeline_template = ubiops.PipelineCreate(\n",
    "    name=pipeline_name,\n",
    "    description='',\n",
    "    input_type='structured',\n",
    "    input_fields=[\n",
    "        {'name':'input_pokemon', 'data_type':'array_string'}\n",
    "    ],\n",
    "    output_type='structured',\n",
    "    output_fields=[\n",
    "        {'name':'output_pokemon', 'data_type':'file'}\n",
    "    ],\n",
    "    labels={'demo': 'pokemon-pipeline'}\n",
    ")\n",
    "\n",
    "api.pipelines_create(\n",
    "    project_name=PROJECT_NAME,\n",
    "    data=pipeline_template\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a pipeline, now we just need to make a version and add our objects.\n",
    "\n",
    "**IMPORTANT**: only run the next cells once your deployments have finished building and are available. Otherwise you will get an error like: \"error\":\"Version is not available: The version is currently in the building stage\"\n",
    "\n",
    "If you get this error, check in the UI if your model is ready and then rerun the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ubiops.utils.wait_for_deployment_version(\n",
    "    client=api.api_client,\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-matcher',\n",
    "    version='v1',\n",
    "    revision_id=upload_response1.revision\n",
    ")\n",
    "\n",
    "ubiops.utils.wait_for_deployment_version(\n",
    "    client=api.api_client,\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-sorter',\n",
    "    version='v1',\n",
    "    revision_id=upload_response2.revision\n",
    ")\n",
    "\n",
    "ubiops.utils.wait_for_deployment_version(\n",
    "    client=api.api_client,\n",
    "    project_name=PROJECT_NAME,\n",
    "    deployment_name='pokemon-vis',\n",
    "    version='v1',\n",
    "    revision_id=upload_response3.revision\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_template = ubiops.PipelineVersionCreate(\n",
    "    version=PIPELINE_VERSION,\n",
    "    request_retention_mode='full',\n",
    "    objects=[\n",
    "        # pokemon matcher\n",
    "        {\n",
    "            'name': \"pokemon-matcher\",\n",
    "            'reference_name': \"pokemon-matcher\",\n",
    "            'version': DEPLOYMENT_VERSION\n",
    "        },\n",
    "        # pokemon sorter\n",
    "        {\n",
    "            'name': \"pokemon-sorter\",\n",
    "            'reference_name': \"pokemon-sorter\",\n",
    "            'version': DEPLOYMENT_VERSION\n",
    "        },\n",
    "        # pokemon visualizer\n",
    "        {\n",
    "            'name': \"pokemon-vis\",\n",
    "            'reference_name': \"pokemon-vis\",\n",
    "            'version': DEPLOYMENT_VERSION\n",
    "        }\n",
    "    ],\n",
    "    attachments=[\n",
    "        # start -> pokemon-matcher\n",
    "        {\n",
    "            'destination_name': \"pokemon-matcher\",\n",
    "            'sources': [{\n",
    "                'source_name': 'pipeline_start',\n",
    "                'mapping': [{\n",
    "                    \"source_field_name\": 'input_pokemon',\n",
    "                    'destination_field_name': 'input_pokemon'\n",
    "                }]\n",
    "            }]\n",
    "        },\n",
    "        # pokemon-matcher -> pokemon-sorter\n",
    "        {\n",
    "            'destination_name': \"pokemon-sorter\",\n",
    "            'sources': [{\n",
    "                'source_name': \"pokemon-matcher\",\n",
    "                'mapping': [{\n",
    "                    \"source_field_name\": 'output_pokemon',\n",
    "                    'destination_field_name': 'input_pokemon'\n",
    "                }]\n",
    "            }]\n",
    "        },\n",
    "        # pokemon-sorter -> pokemon-vis\n",
    "        {\n",
    "            'destination_name': \"pokemon-vis\",\n",
    "            'sources': [{\n",
    "                'source_name': \"pokemon-sorter\",\n",
    "                'mapping': [{\n",
    "                    \"source_field_name\": 'output_pokemon',\n",
    "                    'destination_field_name': 'input_pokemon'\n",
    "                }]\n",
    "            }]\n",
    "        },\n",
    "        # pokemon-vis -> pipeline end\n",
    "        {\n",
    "            'destination_name': \"pipeline_end\",\n",
    "            'sources': [{\n",
    "                'source_name': \"pokemon-vis\",\n",
    "                'mapping': [{\n",
    "                    \"source_field_name\": 'output_pokemon',\n",
    "                    'destination_field_name': 'output_pokemon'\n",
    "                }]\n",
    "            }]\n",
    "        }\n",
    "    ]\n",
    ")\n",
    "\n",
    "api.pipeline_versions_create(project_name=PROJECT_NAME, pipeline_name=pipeline_name, data=pipeline_template)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## All done! Let's close the client properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pokemon pipeline done!\n",
    "If you check in your UbiOps account under pipeline you will find a pokemon-pipeline with our components in it and connected. Let's make a request to it. You can also make a request in the UI with the \"create direct request button\".\n",
    "\n",
    "This might take a while since the models will need a cold start as they have never been used before."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making a request and exploring further\n",
    "You can go ahead to the Web App and take a look in the user interface at what you have just built. If you want you can create a request to the pipeline. Just input a few Pokemon names. For example:\n",
    "\n",
    "```\n",
    "[\n",
    "'Pikachu',\n",
    "'Charmander'\n",
    "]\n",
    "```\n",
    "\n",
    "For any questions, feel free to reach out to us via the customer service portal: https://ubiops.atlassian.net/servicedesk/customer/portals"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.1 64-bit",
   "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.10.1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "vscode": {
   "interpreter": {
    "hash": "98590ff4fe04c8543246b2a01debd3de3c5ca9b666f43f1fa87d5110c692004c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}