CD15_CD16_and_CD15_CD16_DRhi_plots.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPg8dD1CNKdG4KiGbqYBS/h",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/christian-geier/apc-data/blob/main/CD15_CD16_and_CD15_CD16_DRhi_plots.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4sWnW_aJO8vG"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import scipy"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# install dependency\n",
        "pip install statannot"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "agMxxkNTkjFr",
        "outputId": "144259d4-b779-4d87-bd12-7b9747ce5ec4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting statannot\n",
            "  Downloading statannot-0.2.3-py3-none-any.whl (10 kB)\n",
            "Installing collected packages: statannot\n",
            "Successfully installed statannot-0.2.3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 38
        },
        "id": "gAc6PnKyPBPP",
        "outputId": "02b94b72-f4a1-4dac-d78d-c27fc2ec6bac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-bfc9cc14-6337-479c-98ff-05f509afacc4\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-bfc9cc14-6337-479c-98ff-05f509afacc4\">\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": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "\n",
        "df = pd.read_csv(io.BytesIO(uploaded['CD15CD16 CD15CD16 DRhi combined.csv']))"
      ],
      "metadata": {
        "id": "qBauxjI-PxiX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CD15_16_DRhi = df.query('Gate == \"Polygon Gate CD15 CD16 DRhi\"')\n",
        "CD15_16 = df.query('Gate == \"Polygon Gate CD15 CD16\"')"
      ],
      "metadata": {
        "id": "1Jt7x32HJzGC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vars_interest = [\n",
        "'Median CD45RA BUV395 BUV395-A',\n",
        " 'Mean CD45RA BUV395 BUV395-A',\n",
        " 'Median CD16 BUV496 BUV496-A',\n",
        " 'Mean CD16 BUV496 BUV496-A',\n",
        " 'Median CD56 BUV737 BUV737-A',\n",
        " 'Mean CD56 BUV737 BUV737-A',\n",
        " 'Median CCR3 BUV805 BUV805-A',\n",
        " 'Mean CCR3 BUV805 BUV805-A',\n",
        " 'Median CCR7 BV421 BV421-A',\n",
        " 'Mean CCR7 BV421 BV421-A',\n",
        " 'Median CD11c eFluor450 eFluor 450-A',\n",
        " 'Mean CD11c eFluor450 eFluor 450-A',\n",
        " 'Median CD123 BV510 BV510-A',\n",
        " 'Mean CD123 BV510 BV510-A',\n",
        " 'Median HLA-DR V500 V500-A',\n",
        " 'Mean HLA-DR V500 V500-A',\n",
        " 'Median CD15 BV605 BV605-A',\n",
        " 'Mean CD15 BV605 BV605-A',\n",
        " 'Median CD86 BV711 BV711-A',\n",
        " 'Mean CD86 BV711 BV711-A',\n",
        " 'Median CD163 BV785 BV785-A',\n",
        " 'Mean CD163 BV785 BV785-A',\n",
        " 'Median CD141 BB515 BB515-A',\n",
        " 'Mean CD141 BB515 BB515-A',\n",
        " 'Median CD14 SB550 Spark Blue 550-A',\n",
        " 'Mean CD14 SB550 Spark Blue 550-A',\n",
        " 'Median CD45 PerCP PerCP-A',\n",
        " 'Mean CD45 PerCP PerCP-A',\n",
        " 'Median CD3 PerCP-Cy5.5 PerCP-Cy5.5-A',\n",
        " 'Mean CD3 PerCP-Cy5.5 PerCP-Cy5.5-A',\n",
        " 'Median CD275 PE PE-A',\n",
        " 'Mean CD275 PE PE-A',\n",
        " 'Median CD155 PE-Dazzle594 PE-Dazzle594-A',\n",
        " 'Mean CD155 PE-Dazzle594 PE-Dazzle594-A',\n",
        " 'Median PI-Viability Propidium Iodide-A',\n",
        " 'Mean PI-Viability Propidium Iodide-A',\n",
        " 'Median CD83 PE-Cy5 PE-Cy5-A',\n",
        " 'Mean CD83 PE-Cy5 PE-Cy5-A',\n",
        " 'Median CCR2 PE-Cy7 PE-Cy7-A',\n",
        " 'Mean CCR2 PE-Cy7 PE-Cy7-A',\n",
        " 'Median CD1c AF647 Alexa Fluor 647-A',\n",
        " 'Mean CD1c AF647 Alexa Fluor 647-A',\n",
        " 'Median CD19 Spark NIR 685 Spark NIR 685-A',\n",
        " 'Mean CD19 Spark NIR 685 Spark NIR 685-A',\n",
        " 'Median CD303 APC-Fire750 APC-Fire 750-A',\n",
        " 'Mean CD303 APC-Fire750 APC-Fire 750-A',\n",
        " 'Median AF-A',\n",
        " 'Mean AF-A',\n",
        " '% non-lymphoid APC'\n",
        " ]"
      ],
      "metadata": {
        "id": "Mmeh8J7tfVKw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# set labels\n",
        "\n",
        "CD15_16_DRhi['status'] = CD15_16_DRhi['status'].replace({'RA' : 'RA (n=13)', 'HD control' : 'HD (n=9)'})\n",
        "CD15_16['status'] = CD15_16['status'].replace({'RA' : 'RA (n=13)', 'HD control' : 'HD (n=9)'})"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "60b4e6UdKVJS",
        "outputId": "b2e2faa9-306a-46a8-9d40-b05999c9facb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-7-842998e7fc53>:1: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  CD15_16_DRhi['status'] = CD15_16_DRhi['status'].replace({'RA' : 'RA (n=13)', 'HD control' : 'HD (n=9)'})\n",
            "<ipython-input-7-842998e7fc53>:2: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  CD15_16['status'] = CD15_16['status'].replace({'RA' : 'RA (n=13)', 'HD control' : 'HD (n=9)'})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creates the plot for CD15_CD16_DRhi\n",
        "\n",
        "f, ax = plt.subplots()\n",
        "\n",
        "splot = sns.stripplot(y=\"% non-lymphoid APC\", x=\"status\", hue=\"index_pt\", legend=False, data=CD15_16_DRhi, s=10)\n",
        "# splot.set(yscale=\"log\")\n",
        "from matplotlib.ticker import StrMethodFormatter, NullFormatter\n",
        "import matplotlib.ticker as mticker\n",
        "ax.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.1f'))\n",
        "\n",
        "# statistical annotation\n",
        "from statannot import add_stat_annotation\n",
        "\n",
        "plt.tick_params(\n",
        "    axis='x',          # changes apply to the x-axis\n",
        "    which='both',      # both major and minor ticks are affected\n",
        "    bottom=False,      # ticks along the bottom edge are off\n",
        "    top=False,         # ticks along the top edge are off\n",
        "    labelbottom=True) # labels along the bottom edge are off\n",
        "\n",
        "plt.tick_params(\n",
        "    axis='y',          # changes apply to the x-axis\n",
        "    which='minor',      # both major and minor ticks are affected\n",
        "    left=False)\n",
        "\n",
        "ax.spines['top'].set_visible(False)\n",
        "ax.spines['right'].set_visible(False)\n",
        "ax.spines['bottom'].set_visible(False)\n",
        "ax.spines['left'].set_visible(False)\n",
        "\n",
        "add_stat_annotation(ax, data=CD15_16_DRhi, x=\"status\", y=\"% non-lymphoid APC\",\n",
        "                    box_pairs=[(\"HD (n=9)\", \"RA (n=13)\")],\n",
        "                    test='Kruskal', text_format='star', loc='outside', verbose=2)\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 627
        },
        "id": "m1nydqDvZgQI",
        "outputId": "734894c4-7d86-47ca-b47d-64c6171d9c31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "p-value annotation legend:\n",
            "ns: 5.00e-02 < p <= 1.00e+00\n",
            "*: 1.00e-02 < p <= 5.00e-02\n",
            "**: 1.00e-03 < p <= 1.00e-02\n",
            "***: 1.00e-04 < p <= 1.00e-03\n",
            "****: p <= 1.00e-04\n",
            "\n",
            "HD (n=9) v.s. RA (n=13): Kruskal-Wallis paired samples with Bonferroni correction, P_val=4.484e-04 stat=1.232e+01\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f, ax = plt.subplots()\n",
        "\n",
        "splot = sns.stripplot(y=\"% live leukocyte singlets\", x=\"status\", hue=\"status\", legend=False, data=CD15_16, s=10)\n",
        "from matplotlib.ticker import StrMethodFormatter, NullFormatter\n",
        "import matplotlib.ticker as mticker\n",
        "ax.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.1f'))\n",
        "\n",
        "# statistical annotation\n",
        "from statannot import add_stat_annotation\n",
        "\n",
        "plt.tick_params(\n",
        "    axis='x',          # changes apply to the x-axis\n",
        "    which='both',      # both major and minor ticks are affected\n",
        "    bottom=False,      # ticks along the bottom edge are off\n",
        "    top=False,         # ticks along the top edge are off\n",
        "    labelbottom=True) # labels along the bottom edge are off\n",
        "\n",
        "plt.tick_params(\n",
        "    axis='y',          # changes apply to the x-axis\n",
        "    which='minor',      # both major and minor ticks are affected\n",
        "    left=False)\n",
        "\n",
        "ax.spines['top'].set_visible(False)\n",
        "ax.spines['right'].set_visible(False)\n",
        "ax.spines['bottom'].set_visible(False)\n",
        "ax.spines['left'].set_visible(False)\n",
        "\n",
        "add_stat_annotation(ax, data=CD15_16, x=\"status\", y=\"% live leukocyte singlets\",\n",
        "                    box_pairs=[(\"HD (n=9)\", \"RA (n=13)\")],\n",
        "                    test='Kruskal', text_format='star', loc='outside', verbose=2)\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "JwDMPKWXax5y",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 645
        },
        "outputId": "db124d3c-226c-41d0-883d-57a9ef56f879"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "p-value annotation legend:\n",
            "ns: 5.00e-02 < p <= 1.00e+00\n",
            "*: 1.00e-02 < p <= 5.00e-02\n",
            "**: 1.00e-03 < p <= 1.00e-02\n",
            "***: 1.00e-04 < p <= 1.00e-03\n",
            "****: p <= 1.00e-04\n",
            "\n",
            "HD (n=9) v.s. RA (n=13): Kruskal-Wallis paired samples with Bonferroni correction, P_val=6.577e-04 stat=1.161e+01\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}