External_data_Local_Files,_Drive,_Sheets,_and_Cloud_Storage.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/islamicity/VirtualOffice/blob/master/External_data_Local_Files%2C_Drive%2C_Sheets%2C_and_Cloud_Storage.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Z2jcRKwUHqV"
      },
      "source": [
        "This notebook provides recipes for loading and saving data from external sources."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eikfzi8ZT_rW"
      },
      "source": [
        "# Local file system"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BaCkyg5CV5jF"
      },
      "source": [
        "## Uploading files from your local file system\n",
        "\n",
        "`files.upload` returns a dictionary of the files which were uploaded.\n",
        "The dictionary is keyed by the file name and values are the data which were uploaded."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "vz-jH8T_Uk2c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "9bfe2d6c-651b-44e8-a053-54e47ee3ae76"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f737aa59-e650-40e5-8033-24ce0637f098\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f737aa59-e650-40e5-8033-24ce0637f098\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving Pembiayaan UMKM - project.csv to Pembiayaan UMKM - project.csv\n",
            "User uploaded file \"Pembiayaan UMKM - project.csv\" with length 134289 bytes\n"
          ]
        }
      ],
      "source": [
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "  print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "      name=fn, length=len(uploaded[fn])))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hauvGV4hV-Mh"
      },
      "source": [
        "## Downloading files to your local file system\n",
        "\n",
        "`files.download` will invoke a browser download of the file to your local computer.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "p2E4EKhCWEC5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "127809a0-18db-46eb-8c4a-a9efdd4fbff6"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_a21b4a3f-3a51-4574-90e1-65d1bb842792\", \"example.txt\", 12)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "from google.colab import files\n",
        "\n",
        "with open('example.txt', 'w') as f:\n",
        "  f.write('some content')\n",
        "\n",
        "files.download('example.txt')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c2W5A2px3doP"
      },
      "source": [
        "# Google Drive\n",
        "\n",
        "You can access files in Drive in a number of ways, including:\n",
        "- Mounting your Google Drive in the runtime's virtual machine\n",
        "- Using a wrapper around the API such as [PyDrive](https://pythonhosted.org/PyDrive/)\n",
        "- Using the [native REST API](https://developers.google.com/drive/v3/web/about-sdk)\n",
        "\n",
        "\n",
        "\n",
        "Examples of each are below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u22w3BFiOveA"
      },
      "source": [
        "## Mounting Google Drive locally\n",
        "\n",
        "The example below shows how to mount your Google Drive on your runtime using an authorization code, and how to write and read files there. Once executed, you will be able to see the new file (`foo.txt`) at [https://drive.google.com/](https://drive.google.com/).\n",
        "\n",
        "This only supports reading, writing, and moving files; to programmatically modify sharing settings or other metadata, use one of the other options below.\n",
        "\n",
        "**Note:** When using the 'Mount Drive' button in the file browser, no authentication codes are necessary for notebooks that have only been edited by the current user."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RWSJpsyKqHjH",
        "outputId": "be12e9bb-e80e-4017-a05b-970018b06d85"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XDg9OBaYqRMd",
        "outputId": "d6db8289-3838-49f1-d032-32b2df02b30a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Google Drive!"
          ]
        }
      ],
      "source": [
        "with open('/content/drive/My Drive/foo.txt', 'w') as f:\n",
        "  f.write('Hello Google Drive!')\n",
        "!cat /content/drive/My\\ Drive/foo.txt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D78AM1fFt2ty",
        "outputId": "bbf0f57c-771e-4710-96d1-8e277aa3b518"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All changes made in this colab session should now be visible in Drive.\n"
          ]
        }
      ],
      "source": [
        "drive.flush_and_unmount()\n",
        "print('All changes made in this colab session should now be visible in Drive.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7taylj9wpsA2"
      },
      "source": [
        "## PyDrive\n",
        "\n",
        "The examples below demonstrate authentication and file upload/download using PyDrive. More examples are available in the [PyDrive documentation](https://pythonhosted.org/PyDrive/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "zU5b6dlRwUQk"
      },
      "outputs": [],
      "source": [
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XkHZtRhm09QS"
      },
      "source": [
        "Authenticate and create the PyDrive client.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "1w7lrGcW08Ds"
      },
      "outputs": [],
      "source": [
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZF3Topk31DCF"
      },
      "source": [
        "Create and upload a text file.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vBuUW-q41tb7",
        "outputId": "fb37192d-8cb5-4a11-e547-ca225683b494"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Uploaded file with ID 1wwP_Kh7C5J8uB9xDSCeGaL9am229TkGH\n"
          ]
        }
      ],
      "source": [
        "uploaded = drive.CreateFile({'title': 'Sample upload 1.txt'})\n",
        "uploaded.SetContentString('Sample upload 1 file content')\n",
        "uploaded.Upload()\n",
        "print('Uploaded file with ID {}'.format(uploaded.get('id')))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbOFN3d_1tcG"
      },
      "source": [
        "Load a file by ID and print its contents.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eFOvsAYk1tcH",
        "outputId": "cb936e80-8d1e-43c5-87b2-a6893790839d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloaded content \"Sample upload 1 file content\"\n"
          ]
        }
      ],
      "source": [
        "downloaded = drive.CreateFile({'id': uploaded.get('id')})\n",
        "print('Downloaded content \"{}\"'.format(downloaded.GetContentString()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRQ5_yMcqJiV"
      },
      "source": [
        "## Drive REST API\n",
        "\n",
        "In order to use the Drive API, we must first authenticate and construct an API client.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "r-exJtdG3XwJ"
      },
      "outputs": [],
      "source": [
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "from googleapiclient.discovery import build\n",
        "drive_service = build('drive', 'v3')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eDLm7MHQEr2U"
      },
      "source": [
        "With this client, we can use any of the functions in the [Google Drive API reference](https://developers.google.com/drive/v3/reference/). Examples follow.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bRFyEsdfBxJ9"
      },
      "source": [
        "### Creating a new Drive file with data from Python\n",
        "\n",
        "First, create a local file to upload."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F1-nafvN-NwW",
        "outputId": "198bcaf5-b15f-43d9-9e6c-9572e4b06590"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/to_upload.txt contains:\n",
            "my sample file"
          ]
        }
      ],
      "source": [
        "with open('/tmp/to_upload.txt', 'w') as f:\n",
        "  f.write('my sample file')\n",
        "\n",
        "print('/tmp/to_upload.txt contains:')\n",
        "!cat /tmp/to_upload.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r5X77CZ5_G-C"
      },
      "source": [
        "Upload it using the [`files.create`](https://developers.google.com/drive/v3/reference/files/create) method. Further details on uploading files are available in the [developer documentation](https://developers.google.com/drive/v3/web/manage-uploads)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Jv6jh6HEpP8",
        "outputId": "ca364a18-359a-4c22-cc86-364f4e4e6950"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "File ID: 10AKACN9V-bjTyBlNEGQHPBr-UffCJExc\n"
          ]
        }
      ],
      "source": [
        "from googleapiclient.http import MediaFileUpload\n",
        "\n",
        "file_metadata = {\n",
        "  'name': 'Sample file',\n",
        "  'mimeType': 'text/plain'\n",
        "}\n",
        "media = MediaFileUpload('/tmp/to_upload.txt', \n",
        "                        mimetype='text/plain',\n",
        "                        resumable=True)\n",
        "created = drive_service.files().create(body=file_metadata,\n",
        "                                       media_body=media,\n",
        "                                       fields='id').execute()\n",
        "print('File ID: {}'.format(created.get('id')))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j5VyISCKFrqU"
      },
      "source": [
        "After executing the cell above, you will see a new file named 'Sample file' at [https://drive.google.com/](https://drive.google.com/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P3KX0Sm0E2sF"
      },
      "source": [
        "### Downloading data from a Drive file into Python\n",
        "\n",
        "Download the file we uploaded above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hEzpzWYWsYKg",
        "outputId": "acc7fde3-d7f2-4e03-b276-f59643dedd62"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloaded file contents are: b'my sample file'\n"
          ]
        }
      ],
      "source": [
        "file_id = created.get('id')\n",
        "\n",
        "import io\n",
        "from googleapiclient.http import MediaIoBaseDownload\n",
        "\n",
        "request = drive_service.files().get_media(fileId=file_id)\n",
        "downloaded = io.BytesIO()\n",
        "downloader = MediaIoBaseDownload(downloaded, request)\n",
        "done = False\n",
        "while done is False:\n",
        "  # _ is a placeholder for a progress object that we ignore.\n",
        "  # (Our file is small, so we skip reporting progress.)\n",
        "  _, done = downloader.next_chunk()\n",
        "\n",
        "downloaded.seek(0)\n",
        "print('Downloaded file contents are: {}'.format(downloaded.read()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ImztleG2Ciae"
      },
      "source": [
        "In order to download a different file, set `file_id` above to the ID of that file, which will look like \"1uBtlaggVyWshwcyP6kEI-y_W3P8D26sz\"."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sOm9PFrT8mGG"
      },
      "source": [
        "# Google Sheets\n",
        "\n",
        "Our examples below use the open-source [`gspread`](https://github.com/burnash/gspread) library for interacting with Google Sheets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qzi9VsEqzI-o"
      },
      "source": [
        "Import the library, authenticate, and create the interface to Sheets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "6d0xJz3VzLOo"
      },
      "outputs": [],
      "source": [
        "from google.colab import auth\n",
        "auth.authenticate_user()\n",
        "\n",
        "import gspread\n",
        "from google.auth import default\n",
        "creds, _ = default()\n",
        "\n",
        "gc = gspread.authorize(creds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yjrZQUrt6kKj"
      },
      "source": [
        "Below is a small set of `gspread` examples. Additional examples are available at the [`gspread` GitHub page](https://github.com/burnash/gspread#more-examples)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgXqE02UofZG"
      },
      "source": [
        "## Creating a new sheet with data from Python"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "tnnYKhGfzGeP"
      },
      "outputs": [],
      "source": [
        "sh = gc.create('My first cool spreadsheet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v9Ia9JVc6Zvk"
      },
      "source": [
        "After executing the cell above, you will see a new spreadsheet named 'My cool spreadsheet' at [https://sheets.google.com](https://sheets.google.com/).\n",
        "\n",
        "Open our new sheet and add some random data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ASdgLIt2s-ux",
        "outputId": "121da686-8334-4fd8-89a8-f2d94bac9abc"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'spreadsheetId': '1jP7k1htA6muisKcT_3l8y_FM5uCfVOTroeDj44ZKgnw',\n",
              " 'updatedRange': 'Sheet1!A1:C2',\n",
              " 'updatedRows': 2,\n",
              " 'updatedColumns': 3,\n",
              " 'updatedCells': 6}"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "worksheet = gc.open('My first cool spreadsheet').sheet1\n",
        "\n",
        "cell_list = worksheet.range('A1:C2')\n",
        "\n",
        "import random\n",
        "for cell in cell_list:\n",
        "  cell.value = random.randint(1, 10)\n",
        "\n",
        "worksheet.update_cells(cell_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k9q0pp33dckN"
      },
      "source": [
        "## Downloading data from a sheet into Python as a Pandas DataFrame\n",
        "\n",
        "Read back the random data that we inserted above and convert the result into a [Pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "J4QxBareshEV",
        "outputId": "91b64476-08a3-42c4-eefc-7f5753a14da3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['4', '9', '10'], ['6', '2', '6']]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   0  1   2\n",
              "0  4  9  10\n",
              "1  6  2   6"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-14e7be0a-5d2f-4137-ab83-0e3b49b854e7\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0</th>\n",
              "      <th>1</th>\n",
              "      <th>2</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>4</td>\n",
              "      <td>9</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>6</td>\n",
              "      <td>2</td>\n",
              "      <td>6</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-14e7be0a-5d2f-4137-ab83-0e3b49b854e7')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-14e7be0a-5d2f-4137-ab83-0e3b49b854e7 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-14e7be0a-5d2f-4137-ab83-0e3b49b854e7');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "worksheet = gc.open('My first cool spreadsheet').sheet1\n",
        "\n",
        "# get_all_values gives a list of rows.\n",
        "rows = worksheet.get_all_values()\n",
        "print(rows)\n",
        "\n",
        "import pandas as pd\n",
        "pd.DataFrame.from_records(rows)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7c8WYyQdh5i"
      },
      "source": [
        "# Google Cloud Storage (GCS)\n",
        "\n",
        "In order to use Colaboratory with GCS, you'll need to create a [Google Cloud project](https://cloud.google.com/storage/docs/projects) or use a pre-existing one.\n",
        "\n",
        "Specify your project ID below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "VYC5CyAbAtU7"
      },
      "outputs": [],
      "source": [
        "project_id = 'container-registry-16515'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5iRYBSVCbAlK"
      },
      "source": [
        "Files in GCS are contained in [buckets](https://cloud.google.com/storage/docs/buckets).\n",
        "\n",
        "Buckets must have a globally-unique name, so we generate one here."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "JgjL1e0ua-kN"
      },
      "outputs": [],
      "source": [
        "import uuid\n",
        "bucket_name = 'colab-sample-bucket-' + str(uuid.uuid1())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-OtHMRVda9pJ"
      },
      "source": [
        "In order to access GCS, we must authenticate."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "NQX0hbfYaEKc"
      },
      "outputs": [],
      "source": [
        "from google.colab import auth\n",
        "auth.authenticate_user()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YLPAbDDFaLXU"
      },
      "source": [
        "GCS can be accessed via the `gsutil` command-line utility or via the native Python API."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvuZEyRQXmyS"
      },
      "source": [
        "## `gsutil`\n",
        "\n",
        "First, we configure `gsutil` to use the project we specified above by using `gcloud`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TpnuFITI6Tzu",
        "outputId": "2fbbe9ff-8131-4613-f2d5-10df89e93df7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Updated property [core/project].\n"
          ]
        }
      ],
      "source": [
        "!gcloud config set project {project_id}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NAM6vyXAfVUj"
      },
      "source": [
        "Create a local file to upload."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LADpx7LReOMk",
        "outputId": "a2605d44-54b9-4571-b022-5fcfbaa10489"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/to_upload.txt contains:\n",
            "my sample file"
          ]
        }
      ],
      "source": [
        "with open('/tmp/to_upload.txt', 'w') as f:\n",
        "  f.write('my sample file')\n",
        "\n",
        "print('/tmp/to_upload.txt contains:')\n",
        "!cat /tmp/to_upload.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sSz0aInzWXFI"
      },
      "source": [
        "Make a bucket to which we'll upload the file ([documentation](https://cloud.google.com/storage/docs/gsutil/commands/mb))."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bcpvh_R_6jKB",
        "outputId": "e818b420-aa9d-4c82-d6dc-10c78d4919ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Creating gs://colab-sample-bucket-b7fb90a8-584e-11ed-bd87-0242ac1c0002/...\n"
          ]
        }
      ],
      "source": [
        "!gsutil mb gs://{bucket_name}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MHPM16gWWNvn"
      },
      "source": [
        "Copy the file to our new bucket ([documentation](https://cloud.google.com/storage/docs/gsutil/commands/cp))."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L5cMl7XV65be",
        "outputId": "5cc43a7b-9875-44f1-f054-58c96f2e9e29"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Copying file:///tmp/to_upload.txt [Content-Type=text/plain]...\n",
            "/ [1 files][   14.0 B/   14.0 B]                                                \n",
            "Operation completed over 1 objects/14.0 B.                                       \n"
          ]
        }
      ],
      "source": [
        "!gsutil cp /tmp/to_upload.txt gs://{bucket_name}/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xAPlMk6nWKNm"
      },
      "source": [
        "Dump the contents of our newly copied file to make sure everything worked ([documentation](https://cloud.google.com/storage/docs/gsutil/commands/cat)).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pJGU6gX-7M-N",
        "outputId": "7790f14d-6957-4fc6-9d02-d7bcfd1f9800"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "my sample file"
          ]
        }
      ],
      "source": [
        "!gsutil cat gs://{bucket_name}/to_upload.txt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qoectKiGOABf",
        "outputId": "0dcef59f-d3f5-4004-f9f4-aa4565f055d3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://console.cloud.google.com/storage/browser?project=container-registry-16515\n"
          ]
        }
      ],
      "source": [
        "#@markdown Once the upload has finished, the data will appear in the Cloud Console storage browser for your project:\n",
        "print('https://console.cloud.google.com/storage/browser?project=' + project_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q2CWQGIghDux"
      },
      "source": [
        "Finally, we'll download the file we just uploaded in the example above. It's as simple as reversing the order in the `gsutil cp` command."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lPdTf-6O73ll",
        "outputId": "c3638468-bcf9-44d9-8fb6-912680121d78"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Copying gs://colab-sample-bucket-b7fb90a8-584e-11ed-bd87-0242ac1c0002/to_upload.txt...\n",
            "/ [0 files][    0.0 B/   14.0 B]                                                \r/ [1 files][   14.0 B/   14.0 B]                                                \r\n",
            "Operation completed over 1 objects/14.0 B.                                       \n",
            "my sample file"
          ]
        }
      ],
      "source": [
        "!gsutil cp gs://{bucket_name}/to_upload.txt /tmp/gsutil_download.txt\n",
        "  \n",
        "# Print the result to make sure the transfer worked.\n",
        "!cat /tmp/gsutil_download.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ENMqxq25szn"
      },
      "source": [
        "## Python API\n",
        "\n",
        "These snippets based on [a larger example](https://github.com/GoogleCloudPlatform/storage-file-transfer-json-python/blob/master/chunked_transfer.py) that shows additional uses of the API.\n",
        "\n",
        " First, we create the service client."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "wkJ5ShIgceqI"
      },
      "outputs": [],
      "source": [
        "from googleapiclient.discovery import build\n",
        "gcs_service = build('storage', 'v1')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R1Hyoh07gQHY"
      },
      "source": [
        "Create a local file to upload."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s1htTNVlgQHe",
        "outputId": "b594fce5-52b1-4a26-af14-588bb2021b22"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/to_upload.txt contains:\n",
            "my sample file"
          ]
        }
      ],
      "source": [
        "with open('/tmp/to_upload.txt', 'w') as f:\n",
        "  f.write('my sample file')\n",
        "\n",
        "print('/tmp/to_upload.txt contains:')\n",
        "!cat /tmp/to_upload.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YJKBHaUlgDhl"
      },
      "source": [
        "Create a bucket in the project specified above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YFVbF4cdhd9Y",
        "outputId": "8f4b9195-4d44-4aca-87a2-26d9cd5b2f16"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Done\n"
          ]
        }
      ],
      "source": [
        "# Use a different globally-unique bucket name from the gsutil example above.\n",
        "import uuid\n",
        "bucket_name = 'colab-sample-bucket-' + str(uuid.uuid1())\n",
        "\n",
        "body = {\n",
        "  'name': bucket_name,\n",
        "  # For a full list of locations, see:\n",
        "  # https://cloud.google.com/storage/docs/bucket-locations\n",
        "  'location': 'us',\n",
        "}\n",
        "gcs_service.buckets().insert(project=project_id, body=body).execute()\n",
        "print('Done')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ppkrR7p4mx_P"
      },
      "source": [
        "Upload the file to our newly created bucket."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cFAq-F2af5TJ",
        "outputId": "87b17e2a-336d-4bc2-e154-60adc9b7fbcc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Upload complete\n"
          ]
        }
      ],
      "source": [
        "from googleapiclient.http import MediaFileUpload\n",
        "\n",
        "media = MediaFileUpload('/tmp/to_upload.txt', \n",
        "                        mimetype='text/plain',\n",
        "                        resumable=True)\n",
        "\n",
        "request = gcs_service.objects().insert(bucket=bucket_name, \n",
        "                                       name='to_upload.txt',\n",
        "                                       media_body=media)\n",
        "\n",
        "response = None\n",
        "while response is None:\n",
        "  # _ is a placeholder for a progress object that we ignore.\n",
        "  # (Our file is small, so we skip reporting progress.)\n",
        "  _, response = request.next_chunk()\n",
        "\n",
        "print('Upload complete')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lvz1BspfpvTl",
        "outputId": "7d19aee6-7a05-48da-c704-bc309b2a3814"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://console.cloud.google.com/storage/browser?project=container-registry-16515\n"
          ]
        }
      ],
      "source": [
        "#@markdown Once the upload has finished, the data will appear in the Cloud Console storage browser for your project:\n",
        "print('https://console.cloud.google.com/storage/browser?project=' + project_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P6aWjfTv7bit"
      },
      "source": [
        "Download the file we just uploaded."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z1_FuDjAozF1",
        "outputId": "c2342c41-a4b5-4280-9e15-8a48ec34db15"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Download complete\n"
          ]
        }
      ],
      "source": [
        "from apiclient.http import MediaIoBaseDownload\n",
        "\n",
        "with open('/tmp/downloaded_from_gcs.txt', 'wb') as f:\n",
        "  request = gcs_service.objects().get_media(bucket=bucket_name,\n",
        "                                            object='to_upload.txt')\n",
        "  media = MediaIoBaseDownload(f, request)\n",
        "\n",
        "  done = False\n",
        "  while not done:\n",
        "    # _ is a placeholder for a progress object that we ignore.\n",
        "    # (Our file is small, so we skip reporting progress.)\n",
        "    _, done = media.next_chunk()\n",
        "\n",
        "print('Download complete')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OnjWcDFogdY2"
      },
      "source": [
        "Inspect the downloaded file.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DxLyhaiBpAGX",
        "outputId": "3ed38c65-a442-4b6b-ece1-1d1031df7d0f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "my sample file"
          ]
        }
      ],
      "source": [
        "!cat /tmp/downloaded_from_gcs.txt"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "External data: Local Files, Drive, Sheets, and Cloud Storage",
      "toc_visible": true,
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}