DKUtils_Documentation_and_Examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DKUtils Documentation & Examples\n",
    "This notebook gives a brief introduction to DKUtils and several examples using the main client that this package provides, DataKitchenClient. Multiple other clients and convenience functions & classes are provided by this package as described in the formal documention.\n",
    "\n",
    "See the [DKUtils Documentation](https://datakitchen.github.io/DKUtils/) for a comprehensive overview of this [DKUtils Python Package](https://pypi.org/project/DKUtils/). Furthermore, the source code is publicly available on [GitHub DataKitchen/DKUtils](https://github.com/DataKitchen/DKUtils)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install DKUtils\n",
    "Install the DKUtils package when you begin using it and anytime a newer version is available that you want to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!pip install -U dkutils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports and Global Variables\n",
    "There are two ways to create a DataKitchenClient instance. The first is via its constructor by explicitly passing in a username and password. This method is typically used in General Purpose Container (GPC) python scripts:\n",
    "```python\n",
    "CLIENT = DataKitchenClient(username, password)\n",
    "```\n",
    "The second uses a DK CLI context in your home directory (see [DKCloudCommand Documentation](https://docs.datakitchen.io/articles/#!datakitchen-help/dkcloudcommand) for more information about the DK CLI).  This method is typically used for local development since it is simpler. In this example, a context is provided, but if you omit the context name, the default is used:\n",
    "```python\n",
    "CLIENT = create_using_context(context='Implementation')\n",
    "```\n",
    "In both instances, kitchen, recipe, and variation variables are optional. If any of these variables will be constant across all of your API calls, it's recommended to set them when instantiating the client:\n",
    "```python\n",
    "CLIENT = DataKitchenClient(username, password, kitchen=KITCHEN, recipe=RECIPE, variation=VARIATION)\n",
    "CLIENT = create_using_context(context='Implementation', kitchen=KITCHEN, recipe=RECIPE, variation=VARIATION)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import json\n",
    "\n",
    "from datetime import datetime, timedelta\n",
    "from pprint import pformat\n",
    "from textwrap import indent\n",
    "\n",
    "from dkutils.constants import INACTIVE_ORDER_STATUS_TYPES\n",
    "from dkutils.datakitchen_api.datakitchen_client import DataKitchenClient, create_using_context\n",
    "\n",
    "LOGGER = logging.getLogger()\n",
    "LOGGER.addHandler(logging.StreamHandler())\n",
    "LOGGER.setLevel(logging.INFO)\n",
    "\n",
    "USERNAME = '[CHANGE_ME]'\n",
    "PASSWORD = '[CHANGE_ME]'\n",
    "CONTEXT  = '[CHANGE_ME]'\n",
    "\n",
    "INDENT    = '    '\n",
    "KITCHEN   = '[CHANGE_ME]'\n",
    "RECIPE    = '[CHANGE_ME]'\n",
    "VARIATION = '[CHANGE_ME]'\n",
    "\n",
    "USE_CONTEXT = True\n",
    "if USE_CONTEXT:\n",
    "    CLIENT = create_using_context(context=CONTEXT, kitchen=KITCHEN, recipe=RECIPE, variation=VARIATION)\n",
    "else:\n",
    "    CLIENT = DataKitchenClient(USERNAME, PASSWORD, kitchen=KITCHEN, recipe=RECIPE, variation=VARIATION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Create an Order](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.create_order)\n",
    "If you didn't specify the kitchen, recipe, and variation when creating the DataKitchen Client, then you must set them before invoking `create_order`. Since we didn't set these fields above, we'll do that first here. There are two ways to do so. Since these attributes are properties with setters, one way is the following:\n",
    "```python\n",
    "CLIENT.kitchen = KITCHEN\n",
    "CLIENT.recipe = RECIPE\n",
    "CLIENT.variation = VARIATION\n",
    "```\n",
    "However, the client employs a somewhat [fluent interface](https://en.wikipedia.org/wiki/Fluent_interface) allowing method chaining for convenience:\n",
    "```python\n",
    "response = CLIENT.set_kitchen(KITCHEN).set_recipe(RECIPE).set_variation(VARIATION).create_order()\n",
    "```\n",
    "\n",
    "After setting the kitchen, recipe, and variation, simply invoke the `create_order` method. If the order takes parameters, an optional dictionary of parameters may be provided:\n",
    "```python\n",
    "parameters = {\n",
    "    'parameter': 'value'\n",
    "}\n",
    "response = CLIENT.create_order(parameters=parameters)\n",
    "```\n",
    "If successful, the created order id is returned in the response and may be used to retrieve the order run id after it starts:\n",
    "```python\n",
    "order_id = response.json()['order_id']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "response = CLIENT.set_kitchen(KITCHEN).set_recipe(RECIPE).set_variation(VARIATION).create_order()\n",
    "order_id = response.json()['order_id']\n",
    "print(f'Created order id {order_id}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Retrieve Order Runs](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.get_order_runs)\n",
    "Given an order id, retrieve the associated order runs. If an order was created as shown above, only a single order run should be retrieved. The order run id is captured in the `hid` field. If the order run has not yet started, the order runs array will be empty. Therefore, you will have to wait for the order run to start. Alternatively, there is a [create_and_monitor_orders](http://dkutils.dk.io/latest/docs/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.create_and_monitor_orders) method that can invoke multiple orders at once and wait for them all to finish. Please visit the provided link for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "order_runs = CLIENT.get_order_runs(order_id)\n",
    "print(f'Order runs: \\n{indent(pformat(order_runs), INDENT)}')\n",
    "\n",
    "order_run_id = order_runs[0]['hid']\n",
    "print(f'Order Run ID: {order_run_id}') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Retrieve Order Run Details](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.get_order_run_details)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "order_run_details = CLIENT.get_order_run_details(order_run_id)\n",
    "print(f'Order run details: \\n{indent(pformat(order_run_details), INDENT)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Retrieve Order Run Status](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.get_order_run_status)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "order_run_status = CLIENT.get_order_run_status(order_run_id)\n",
    "print(f'Order Run Status: {order_run_status}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Retrieve Kitchen Level Overrides](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.get_overrides)\n",
    "Retrieve all overrides for a kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "overrides = CLIENT.get_overrides()\n",
    "print(f'Overrides:\\n{indent(pformat(overrides), INDENT)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Compare Kitchen Level Overrides](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.datakitchen_client.html#dkutils.datakitchen_api.datakitchen_client.DataKitchenClient.compare_overrides)\n",
    "Compare kitchen overrides in your current kitchen with another kitchen. The `other` argument is optional - the default value is the parent kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comparison = CLIENT.compare_overrides(other='IM_Production')\n",
    "print(comparison)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kitchen Methods\n",
    "A [Kitchen class](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html) provides methods for performing kitchen related API requests."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Create Kitchen](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.create)\n",
    "Create a new kitchen and return an instance of the Kitchen class for this new kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.create_kitchen('foo', 'this is a new foo kitchen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Kitchen](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.delete)\n",
    "Delete the current kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "print(kitchen.delete())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Alerts](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.get_alerts)\n",
    "Retrieve alerts set on this kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "alerts = kitchen.get_alerts()\n",
    "pprint(alerts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Add Alerts](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.add_alerts)\n",
    "Add the provided alerts to the kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "kitchen.add_alerts({'OverDuration': ['foo@gmail.com']})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Alerts](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.delete_alerts)\n",
    "Delete the provided kitchen alerts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "kitchen.delete_alerts({'OverDuration': ['foo@gmail.com']})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get Kitchen Settings\n",
    "Retrieve kitchen settings JSON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "kitchen_settings = kitchen._get_settings()\n",
    "pprint(kitchen_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Staff](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.get_staff)\n",
    "Retrieve the staff and their associated roles assigned to this kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "staff = kitchen.get_staff()\n",
    "pprint(staff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Staff](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.delete_staff)\n",
    "Delete the provided staff from this kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "response = kitchen.delete_staff([\n",
    "    'foo@datakitchen.io',\n",
    "    'bar@datakitchen.io',\n",
    "])\n",
    "pprint(response)\n",
    "staff = kitchen.get_staff()\n",
    "pprint(staff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Add Staff](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.add_staff)\n",
    "Add the provided staff to this kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "\n",
    "response = kitchen.add_staff({\n",
    "    'Developer': [\n",
    "        'foo@datakitchen.io',\n",
    "        'bar@datakitchen.io',\n",
    "    ]\n",
    "})\n",
    "pprint(response)\n",
    "staff = kitchen.get_staff()\n",
    "pprint(staff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Update Staff](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.kitchen.html#dkutils.datakitchen_api.kitchen.Kitchen.update_staff)\n",
    "Update roles for the provided staff to this kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "kitchen = client.get_kitchen()\n",
    "response = kitchen.update_staff({\n",
    "    'Admin': [\n",
    "        'foo@datakitchen.io',\n",
    "        'bar@datakitchen.io',\n",
    "    ]\n",
    "})\n",
    "pprint(response)\n",
    "staff = kitchen.get_staff()\n",
    "pprint(staff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recipe Methods\n",
    "A [Recipe class](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe) provides methods for performing recipe related API requests."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Create Recipe](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.create)\n",
    "Create a new recipe in the kitchen set on the provided client and return a Recipe object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "Recipe.create(client, '<RECIPE_NAME>', '<RECIPE_DESCRIPTION>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Recipe](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.delete)\n",
    "Delete this recipe from the provided kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe = Recipe(client, '<RECIPE_NAME>')\n",
    "recipe.delete('<KITCHEN_NAME>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Recipe Files](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.get_recipe_files)\n",
    "Retrieve all the files for this recipe in the provided kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe = Recipe(client, '<RECIPE_NAME>')\n",
    "recipe_files = recipe.get_recipe_files('<KITCHEN_NAME>')\n",
    "pprint(recipe_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Node Files](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.get_node_files)\n",
    "Retrieve all the files associated with the provided list of nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe = Recipe(client, '<RECIPE_NAME>')\n",
    "node_files = recipe.get_node_files('<KITCHEN_NAME>', ['<NODE_NAME_1>', '<NODE_NAME_2>', '<NODE_NAME_3>'])\n",
    "pprint(node_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Update Recipe Files](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.update_recipe_files)\n",
    "Update the files for this recipe in the provided kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe = Recipe(client, '<RECIPE_NAME>')\n",
    "updated_files = {\n",
    "    'new.txt': 'Hello World\\nTest New',\n",
    "    'description.json': '{\\n    \"description\": \"Foo\"\\n}'\n",
    "}\n",
    "recipe.update_recipe_files('<KITCHEN_NAME>', updated_files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Recipe Files](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.recipe.html#dkutils.datakitchen_api.recipe.Recipe.delete_recipe_files)\n",
    "Delete the provided files from this recipe in the provided kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recipe = Recipe(client, '<RECIPE_NAME>')\n",
    "delete_files = [\n",
    "    'new.txt',\n",
    "    'description.json',\n",
    "]\n",
    "recipe.delete_recipe_files('<KITCHEN_NAME>', delete_files)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vault Methods\n",
    "A [Vault class](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#module-dkutils.datakitchen_api.vault) provides methods for modifying a vault's configuration and associated secrets. To retrieve an instance of this class, call `get_vault()` on an instance of the Kitchen class. There are two types of vaults in the DataKitchen platform: global and kitchen. By default, the kitchen vault is modified by the methods below. However, most methods accommodate altering the global vault by passing an `is_global=True` keyword argument (as shown below). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Vault Config](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#dkutils.datakitchen_api.vault.Vault.get_config)\n",
    "Return the vault configuration for the global or kitchen vault."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "vault = client.get_kitchen().get_vault()\n",
    "pprint(vault.get_config())\n",
    "pprint(vault.get_config(is_global=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Update Vault Config](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#dkutils.datakitchen_api.vault.Vault.update_config)\n",
    "Update the custom vault configuration for a Kitchen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "VAULT_CONFIG {\n",
    "    'prefix': '<PREFIX>',\n",
    "    'vault_token': '<TOKEN>',\n",
    "    'vault_url': '<URL>',\n",
    "    'private': '<True|False>',\n",
    "    'inheritable': '<True|False>',\n",
    "\n",
    "}\n",
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "vault = client.get_kitchen().get_vault()\n",
    "pprint(vault.update_config(**VAULT_CONFIG))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Get Vault Secrets](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#dkutils.datakitchen_api.vault.Vault.get_secrets)\n",
    "Get a list of paths for all the secrets in the kitchen or global vault. No secret values are returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "vault = client.get_kitchen().get_vault()\n",
    "pprint(vault.get_secrets())\n",
    "pprint(vault.get_secrets(is_global=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Add/Update Vault Secret](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#dkutils.datakitchen_api.vault.Vault.update_or_add_secret)\n",
    "Update an existing secret value or add a new secret if one does not already exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "vault = client.get_kitchen().get_vault()\n",
    "pprint(vault.update_or_add_secret('<SECRET_PATH>', '<SECRET_VALUE>'))\n",
    "pprint(vault.update_or_add_secret('<SECRET_PATH>', '<SECRET_VALUE>', is_global=True))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Delete Vault Secret](https://datakitchen.github.io/DKUtils/apidoc/dkutils.datakitchen_api.vault.html#dkutils.datakitchen_api.vault.Vault.delete_secret)\n",
    "Delete a secret from vault."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "client.kitchen = '<KITCHEN_NAME>'\n",
    "vault = client.get_kitchen().get_vault()\n",
    "pprint(vault.delete_secret('<SECRET_PATH>'))\n",
    "pprint(vault.delete_secret('<SECRET_PATH>', is_global=True))"
   ]
  }
 ],
 "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}