analysis/notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "latest-edwards",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import plotly.graph_objects as go\n",
    "from pandas.plotting import register_matplotlib_converters\n",
    "from IPython.display import HTML, display\n",
    "from ebmdatalab import charts\n",
    "\n",
    "\n",
    "register_matplotlib_converters()\n",
    "pd.set_option('display.float_format', '{:.0f}'.format)\n",
    "pd.set_option('display.max_colwidth', 100)\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "prerequisite-newton",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('../output/measure_doac_rx_mechanical_valve.csv')\n",
    "df = df.dropna(axis=0)\n",
    "df = df[df['doac']>5]\n",
    "\n",
    "df.to_csv('../output/measures_dropped.csv')\n",
    "selected_stps = []\n",
    "for stp in df['stp'].unique():\n",
    "    subset = df[df['stp']==stp]\n",
    "    if subset['doac'].min() >5:\n",
    "        selected_stps.append(stp)\n",
    "\n",
    "\n",
    "stps = selected_stps[0:20]\n",
    "df[df['stp'].isin(stps)].to_csv('../output/check.csv')\n",
    "num_per_thousand = df['doac']/(df['population']/1000)\n",
    "df['rate'] = num_per_thousand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "beneficial-guarantee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_percentiles(df, period_column=None, column=None, show_outer_percentiles=True):\n",
    "    \"\"\"For each period in `period_column`, compute percentiles across that\n",
    "    range.\n",
    "    Adds `percentile` column.\n",
    "    \"\"\"\n",
    "    deciles = np.arange(0.1, 1, 0.1)\n",
    "    bottom_percentiles = np.arange(0.01, 0.1, 0.01)\n",
    "    top_percentiles = np.arange(0.91, 1, 0.01)\n",
    "    if show_outer_percentiles:\n",
    "        quantiles = np.concatenate((deciles, bottom_percentiles, top_percentiles))\n",
    "    else:\n",
    "        quantiles = deciles\n",
    "    df = df.groupby(period_column)[column].quantile(quantiles).reset_index()\n",
    "    df = df.rename(index=str, columns={\"level_1\": \"percentile\"})\n",
    "    # create integer range of percentiles\n",
    "    df[\"percentile\"] = df[\"percentile\"].apply(lambda x: int(x * 100))\n",
    "    return df\n",
    "\n",
    "\n",
    "def deciles_chart(\n",
    "    df,\n",
    "    period_column=None,\n",
    "    column=None,\n",
    "    title=\"\",\n",
    "    ylabel=\"\", interactive=True\n",
    "):\n",
    "    \"\"\"period_column must be dates / datetimes\n",
    "    \"\"\"\n",
    "\n",
    "    df = add_percentiles(\n",
    "        df,\n",
    "        period_column=period_column,\n",
    "        column=column,\n",
    "        show_outer_percentiles=False,\n",
    "    )\n",
    "\n",
    "    if interactive:\n",
    "        fig = go.Figure()\n",
    "\n",
    "        \n",
    "\n",
    "        for percentile in np.unique(df['percentile']):\n",
    "            df_subset = df[df['percentile'] == percentile]\n",
    "            if percentile == 50:\n",
    "                fig.add_trace(go.Scatter(x=df_subset[period_column], y=df_subset[column], line={\n",
    "                            \"color\": \"blue\", \"dash\": \"solid\", \"width\": 1.2}, name=\"median\"))\n",
    "            else:\n",
    "                fig.add_trace(go.Scatter(x=df_subset[period_column], y=df_subset[column], line={\n",
    "                            \"color\": \"blue\", \"dash\": \"dash\", \"width\": 1}, name=f\"decile {int(percentile/10)}\"))\n",
    "\n",
    "        # Set title\n",
    "        fig.update_layout(\n",
    "            title_text=title,\n",
    "            hovermode='x',\n",
    "            title_x=0.5,\n",
    "\n",
    "\n",
    "        )\n",
    "\n",
    "        fig.update_yaxes(title=ylabel)\n",
    "        fig.update_xaxes(title=\"Date\")\n",
    "\n",
    "        # Add range slider\n",
    "        fig.update_layout(\n",
    "            xaxis=go.layout.XAxis(\n",
    "                rangeselector=dict(\n",
    "                    buttons=list([\n",
    "                        dict(count=1,\n",
    "                            label=\"1m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(count=6,\n",
    "                            label=\"6m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "\n",
    "                        dict(count=1,\n",
    "                            label=\"1y\",\n",
    "                            step=\"year\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(step=\"all\")\n",
    "                    ])\n",
    "                ),\n",
    "                rangeslider=dict(\n",
    "                    visible=True\n",
    "                ),\n",
    "                type=\"date\"\n",
    "            )\n",
    "        )\n",
    "\n",
    "        fig.show()\n",
    "    else:\n",
    "\n",
    "       charts.deciles_chart(\n",
    "        df,\n",
    "        period_column=period_column,\n",
    "        column=column,\n",
    "        title=title,\n",
    "        ylabel=ylabel,\n",
    "        show_outer_percentiles=False,\n",
    "        show_legend=True,\n",
    "    ) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "light-explosion",
   "metadata": {},
   "source": [
    "## DOAC Use in Patients with Mechanical Heart Valves\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "speaking-daniel",
   "metadata": {},
   "source": [
    "### Mechanical Valve Code \n",
    "\n",
    "Number of uses of each code within the mechanical valve codelist as of 01/04/21. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "identified-compression",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>mechanical_valve_code</th>\n",
       "      <th>doac</th>\n",
       "      <th>term</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>174920003</td>\n",
       "      <td>586</td>\n",
       "      <td>Prosthetic mitral valve replacement (&amp; [Bjork Shiley] or [Carpentier Edwards])</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   mechanical_valve_code  doac  \\\n",
       "0              174920003   586   \n",
       "\n",
       "                                                                             term  \n",
       "0  Prosthetic mitral valve replacement (& [Bjork Shiley] or [Carpentier Edwards])  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "codelist = pd.read_csv('../codelists/opensafely-mechanical-or-artificial-valves.csv')\n",
    "\n",
    "recent_df = pd.read_csv('../output/input_2021-04-01.csv')\n",
    "code_count_df = recent_df.groupby(by='mechanical_valve_code')[['doac']].sum().reset_index()\n",
    "\n",
    "def get_term(row, code_column):\n",
    "    row['term'] = codelist['term'][codelist['code'] == row[code_column]].values[0]\n",
    "    return row\n",
    "\n",
    "mechanical_valve_count = code_count_df.apply(lambda row: get_term(row, 'mechanical_valve_code'),axis=1)\n",
    "\n",
    "other_count = 0\n",
    "def get_other_count(row, other_count):\n",
    "    count = row['doac']\n",
    "    if count<=5:\n",
    "        other_count+=count\n",
    "\n",
    "mechanical_valve_count.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "mechanical_valve_count = mechanical_valve_count[mechanical_valve_count['doac']>5]      \n",
    "\n",
    "mechanical_valve_count.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "mechanical_valve_count"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "neither-obligation",
   "metadata": {},
   "source": [
    "### Total Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "complex-layout",
   "metadata": {},
   "outputs": [],
   "source": [
    "total_df = df.groupby(by='date')[['doac', 'population']].sum().reset_index()\n",
    "\n",
    "def plot_measures(df, title,column_to_plot, category=False, y_label='Rate per 1000', interactive=True):\n",
    "\n",
    "    if interactive:\n",
    "\n",
    "        fig = go.Figure()\n",
    "\n",
    "        if category:\n",
    "            for unique_category in df[category].unique():\n",
    "\n",
    "                df_subset = df[df[category] == unique_category]\n",
    "                fig.add_trace(go.Scatter(\n",
    "                    x=df_subset['date'], y=df_subset[column_to_plot], name=unique_category))\n",
    "\n",
    "        else:\n",
    "            fig.add_trace(go.Scatter(\n",
    "                x=df['date'], y=df[column_to_plot]))\n",
    "\n",
    "        # Set title\n",
    "        fig.update_layout(\n",
    "            title_text=title,\n",
    "            hovermode='x',\n",
    "            title_x=0.5,\n",
    "            yaxis=dict(\n",
    "            range=[0, 7000]\n",
    "        )\n",
    "\n",
    "\n",
    "        )\n",
    "\n",
    "        fig.update_yaxes(title=y_label)\n",
    "        fig.update_xaxes(title=\"Date\")\n",
    "\n",
    "        # Add range slider\n",
    "        fig.update_layout(\n",
    "            xaxis=go.layout.XAxis(\n",
    "                rangeselector=dict(\n",
    "                    buttons=list([\n",
    "                        dict(count=1,\n",
    "                            label=\"1m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(count=6,\n",
    "                            label=\"6m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "\n",
    "                        dict(count=1,\n",
    "                            label=\"1y\",\n",
    "                            step=\"year\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(step=\"all\")\n",
    "                    ])\n",
    "                ),\n",
    "                rangeslider=dict(\n",
    "                    visible=True\n",
    "                ),\n",
    "                type=\"date\"\n",
    "            )\n",
    "        )\n",
    "\n",
    "        fig.show()\n",
    "\n",
    "    else:\n",
    "\n",
    "        if category:\n",
    "            for unique_category in df[category].unique():\n",
    "\n",
    "                df_subset = df[df[category] == unique_category]\n",
    "\n",
    "                plt.plot(df_subset['date'], df_subset[column_to_plot], marker='o')\n",
    "        else:\n",
    "            plt.plot(df['date'], df[column_to_plot])\n",
    "\n",
    "        plt.ylabel(y_label)\n",
    "        plt.xlabel('Date')\n",
    "        plt.xticks(rotation='vertical')\n",
    "        plt.title(title)\n",
    "\n",
    "        if category:\n",
    "            plt.legend(df[category].unique(), bbox_to_anchor=(\n",
    "                1.04, 1), loc=\"upper left\")\n",
    "\n",
    "        else:\n",
    "            pass\n",
    "\n",
    "        plt.show()\n",
    "        plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "arbitrary-venice",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_measures(total_df, title='', column_to_plot='doac', category=False, y_label='Total', interactive=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "closed-newsletter",
   "metadata": {},
   "source": [
    "### Practice Breakdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "independent-guitar",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_practice = pd.read_csv('../output/measure_practice.csv')\n",
    "df_practice['date'] = pd.to_datetime(df_practice['date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "minor-victory",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_rate(df, value_col, population_col, rate_per=1000):\n",
    "    num_per_thousand = df[value_col]/(df[population_col]/rate_per)\n",
    "    df['rate'] = num_per_thousand\n",
    "    \n",
    "calculate_rate(df_practice, 'doac', 'population')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "exposed-merchandise",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'charts' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-----------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-afaacc486cda>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdeciles_chart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf_practice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperiod_column\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'date'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolumn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'rate'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Decile chart'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'rate per 1000'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minteractive\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-3-a68829831fd4>\u001b[0m in \u001b[0;36mdeciles_chart\u001b[0;34m(df, period_column, column, title, ylabel, interactive)\u001b[0m\n\u001b[1;32m     92\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 94\u001b[0;31m        charts.deciles_chart(\n\u001b[0m\u001b[1;32m     95\u001b[0m         \u001b[0mdf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     96\u001b[0m         \u001b[0mperiod_column\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mperiod_column\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'charts' is not defined"
     ]
    }
   ],
   "source": [
    "deciles_chart(df_practice, period_column='date', column='rate', title='Decile chart',ylabel='rate per 1000', interactive=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faced-soldier",
   "metadata": {},
   "source": [
    "### STP Breakdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "administrative-sodium",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_stp = pd.read_csv('../output/measure_stp.csv')\n",
    "df_stp['date'] = pd.to_datetime(df_stp['date'])\n",
    "calculate_rate(df_stp, 'doac', 'population')\n",
    "deciles_chart(df_stp, period_column='date', column='rate', title='Decile chart',ylabel='rate per 1000', interactive=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "front-wright",
   "metadata": {},
   "source": [
    "### Breakdown by DOAC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "boring-driving",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_doac_code = pd.read_csv('../output/measure_doac_code.csv')\n",
    "df_doac_code['doac_code'] = df_doac_code['doac_code'].astype('float')\n",
    "\n",
    "def plot_measures(df, title, column_to_plot, category=False, y_label='Rate per 1000', interactive=True):\n",
    "\n",
    "    if interactive:\n",
    "\n",
    "        fig = go.Figure()\n",
    "\n",
    "        if category:\n",
    "            for unique_category in df[category].unique():\n",
    "\n",
    "                df_subset = df[df[category] == unique_category]\n",
    "                fig.add_trace(go.Scatter(\n",
    "                    x=df_subset['date'], y=df_subset[column_to_plot], name=str(unique_category)))\n",
    "\n",
    "        else:\n",
    "            fig.add_trace(go.Scatter(\n",
    "                x=df['date'], y=df[column_to_plot]))\n",
    "\n",
    "        # Set title\n",
    "        fig.update_layout(\n",
    "            title_text=title,\n",
    "            hovermode='x',\n",
    "            title_x=0.5,\n",
    "\n",
    "\n",
    "        )\n",
    "\n",
    "        fig.update_yaxes(title=y_label)\n",
    "        fig.update_xaxes(title=\"Date\")\n",
    "\n",
    "        # Add range slider\n",
    "        fig.update_layout(\n",
    "            xaxis=go.layout.XAxis(\n",
    "                rangeselector=dict(\n",
    "                    buttons=list([\n",
    "                        dict(count=1,\n",
    "                            label=\"1m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(count=6,\n",
    "                            label=\"6m\",\n",
    "                            step=\"month\",\n",
    "                            stepmode=\"backward\"),\n",
    "\n",
    "                        dict(count=1,\n",
    "                            label=\"1y\",\n",
    "                            step=\"year\",\n",
    "                            stepmode=\"backward\"),\n",
    "                        dict(step=\"all\")\n",
    "                    ])\n",
    "                ),\n",
    "                rangeslider=dict(\n",
    "                    visible=True\n",
    "                ),\n",
    "                type=\"date\"\n",
    "            )\n",
    "        )\n",
    "\n",
    "        fig.show()\n",
    "        \n",
    "\n",
    "    else:\n",
    "\n",
    "        if category:\n",
    "            for unique_category in df[category].unique():\n",
    "\n",
    "                df_subset = df[df[category] == unique_category]\n",
    "\n",
    "                plt.plot(df_subset['date'], df_subset[column_to_plot])\n",
    "        else:\n",
    "            plt.plot(df['date'], df[column_to_plot])\n",
    "\n",
    "        plt.ylabel(y_label)\n",
    "        plt.xlabel('Date')\n",
    "        plt.xticks(rotation='vertical')\n",
    "        plt.title(title)\n",
    "\n",
    "        if category:\n",
    "            plt.legend(df[category].unique(), bbox_to_anchor=(\n",
    "                1.04, 1), loc=\"upper left\")\n",
    "\n",
    "        else:\n",
    "            pass\n",
    "\n",
    "\n",
    "        plt.show()\n",
    "        plt.clf()\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "graduate-impression",
   "metadata": {},
   "outputs": [],
   "source": [
    "calculate_rate(df_doac_code, 'doac', 'population')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "angry-lightweight",
   "metadata": {},
   "source": [
    "Total use of each doac across study period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "inappropriate-central",
   "metadata": {},
   "outputs": [],
   "source": [
    "codelist = pd.read_csv('../codelists/opensafely-direct-acting-oral-anticoagulants-doac.csv')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "noticed-lafayette",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>doac_code</th>\n",
       "      <th>doac</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19506911000001104</td>\n",
       "      <td>12026</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          doac_code  doac\n",
       "0 19506911000001104 12026"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_term(row, code_column):\n",
    "    \n",
    "\n",
    "    row['term'] = codelist['chemical'][codelist['id'] == row[code_column]].values[0]\n",
    "    \n",
    "    return row\n",
    "\n",
    "\n",
    "df_doac_code_count = df_doac_code.groupby(by='doac_code')[['doac']].sum().reset_index()\n",
    "\n",
    "df_doac_code_count.apply(lambda row: get_term(row, 'doac_code'),axis=1)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "other_count = 0\n",
    "def get_other_count(row):\n",
    "    count = row['doac']\n",
    "    if count<=5:\n",
    "        other_count+=count\n",
    "\n",
    "df_doac_code_count.apply(lambda row: get_other_count(row), axis=1)\n",
    "df_doac_code_count = df_doac_code_count[df_doac_code_count['doac']>5]      \n",
    "\n",
    "df_doac_code_count.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "df_doac_code_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "czech-matrix",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_measures(df_doac_code, '', 'rate', category='doac_code', y_label='Rate per 1000', interactive=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "impossible-walnut",
   "metadata": {},
   "source": [
    "### Demographic breakdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "blind-virus",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.options.mode.chained_assignment = None\n",
    "from collections import Counter\n",
    "demographic_df = pd.read_csv('../output/input_demographics.csv')\n",
    "demographic_df_doac = demographic_df[(demographic_df['mechanical_valve']==1)&(demographic_df['doac']==1)]\n",
    "\n",
    "\n",
    "\n",
    "demographics = ['sex', 'age_band', 'atrial_fib', 'imd', 'eth2001']\n",
    "demographic_counts = {}\n",
    "\n",
    "for dem in demographics:\n",
    "    column = demographic_df_doac[dem]\n",
    "    count_dict = Counter(column.dropna())\n",
    "    \n",
    "    demographic_counts[dem] = count_dict\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "enabling-respect",
   "metadata": {},
   "source": [
    "#### Sex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "sized-fitting",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>count</th>\n",
       "      <th>%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>F</th>\n",
       "      <td>1228</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>M</th>\n",
       "      <td>1174</td>\n",
       "      <td>48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>U</th>\n",
       "      <td>21</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   count  %\n",
       "F   1228 51\n",
       "M   1174 48\n",
       "U     21  1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sex_dict = demographic_counts['sex']\n",
    "sex_df = pd.DataFrame.from_dict(sex_dict, orient='index').rename(columns={'index': 'row', 0: 'count'})\n",
    "\n",
    "total = sex_df['count'].sum()\n",
    "\n",
    "\n",
    "def calculate_percent(row, total):\n",
    "    row['%'] = (row['count']/total)*100\n",
    "    return row\n",
    "sex_df = sex_df.apply(lambda row: calculate_percent(row, total), axis=1)\n",
    "\n",
    "other_count = 0\n",
    "def get_other_count(row, other_count):\n",
    "    count = row['count']\n",
    "    if count<=5:\n",
    "        other_count+=count\n",
    "\n",
    "sex_df.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "sex_df = sex_df[sex_df['count']>5]      \n",
    "\n",
    "sex_df.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "sex_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peripheral-joseph",
   "metadata": {},
   "source": [
    "#### Ethnicity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "offshore-angel",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>count</th>\n",
       "      <th>%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1227</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>594</td>\n",
       "      <td>25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>272</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>77</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>175</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>36</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>22</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>20</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   count  %\n",
       "1   1227 51\n",
       "2    594 25\n",
       "3    272 11\n",
       "5     77  3\n",
       "4    175  7\n",
       "6     36  1\n",
       "7     22  1\n",
       "8     20  1"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ethnicity_dict = demographic_counts['eth2001']\n",
    "ethnicity_df = pd.DataFrame.from_dict(ethnicity_dict, orient='index').rename(columns={'index': 'row', 0: 'count'})\n",
    "\n",
    "total = ethnicity_df['count'].sum()\n",
    "\n",
    "\n",
    "def calculate_percent(row, total):\n",
    "    row['%'] = (row['count']/total)*100\n",
    "    return row\n",
    "ethnicity_df = ethnicity_df.apply(lambda row: calculate_percent(row, total), axis=1)\n",
    "\n",
    "other_count = 0\n",
    "\n",
    "ethnicity_df.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "ethnicity_df = ethnicity_df[ethnicity_df['count']>5]      \n",
    "\n",
    "ethnicity_df.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "ethnicity_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "confirmed-failure",
   "metadata": {},
   "source": [
    "#### IMD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "demographic-diary",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>imd</th>\n",
       "      <th>count</th>\n",
       "      <th>%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Most deprived</td>\n",
       "      <td>82</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>92</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>104</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Least deprived</td>\n",
       "      <td>107</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>82</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              imd  count  %\n",
       "0   Most deprived     82 18\n",
       "1               4     92 20\n",
       "2               2    104 22\n",
       "3  Least deprived    107 23\n",
       "4               3     82 18"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imd_dict = demographic_counts['imd']\n",
    "imd_df = pd.DataFrame.from_dict(imd_dict, orient='index').rename(columns={'index': 'row', 0: 'count'})\n",
    "\n",
    "total = imd_df['count'].sum()\n",
    "\n",
    "\n",
    "def calculate_percent(row, total):\n",
    "    row['%'] = (row['count']/total)*100\n",
    "    return row\n",
    "imd_df = imd_df.apply(lambda row: calculate_percent(row, total), axis=1)\n",
    "imd_df = imd_df.reset_index()\n",
    "\n",
    "imd_df = imd_df.rename(columns={'index': 'imd'})\n",
    "\n",
    "\n",
    "def calculate_imd_group(df):\n",
    "    imd_column = pd.to_numeric(df['imd'])\n",
    "    df['imd'] = pd.qcut(imd_column, q=5,duplicates=\"drop\", labels=['Most deprived', '2', '3', '4', 'Least deprived'])      \n",
    "    \n",
    "    return df\n",
    "\n",
    "imd_df = calculate_imd_group(imd_df)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "other_count = 0\n",
    "\n",
    "\n",
    "imd_df.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "imd_df = imd_df[imd_df['count']>5]      \n",
    "\n",
    "imd_df.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "imd_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "american-vegetation",
   "metadata": {},
   "source": [
    "#### AF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "presidential-jason",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>count</th>\n",
       "      <th>%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2390</td>\n",
       "      <td>99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   count  %\n",
       "0   2390 99\n",
       "1     33  1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "af_dict = demographic_counts['atrial_fib']\n",
    "af_df = pd.DataFrame.from_dict(af_dict, orient='index').rename(columns={'index': 'row', 0: 'count'})\n",
    "\n",
    "total = af_df['count'].sum()\n",
    "\n",
    "\n",
    "def calculate_percent(row, total):\n",
    "    row['%'] = (row['count']/total)*100\n",
    "    return row\n",
    "af_df = af_df.apply(lambda row: calculate_percent(row, total), axis=1)\n",
    "\n",
    "other_count = 0\n",
    "\n",
    "\n",
    "af_df.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "af_df = af_df[af_df['count']>5]      \n",
    "\n",
    "af_df.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "af_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operational-lambda",
   "metadata": {},
   "source": [
    "#### Age Band"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "northern-senate",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>count</th>\n",
       "      <th>%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>40-49</th>\n",
       "      <td>344</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50-59</th>\n",
       "      <td>311</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80+</th>\n",
       "      <td>277</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0-19</th>\n",
       "      <td>315</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20-29</th>\n",
       "      <td>307</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>70-79</th>\n",
       "      <td>304</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30-39</th>\n",
       "      <td>276</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60-69</th>\n",
       "      <td>288</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       count  %\n",
       "40-49    344 14\n",
       "50-59    311 13\n",
       "80+      277 11\n",
       "0-19     315 13\n",
       "20-29    307 13\n",
       "70-79    304 13\n",
       "30-39    276 11\n",
       "60-69    288 12"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age_dict = demographic_counts['age_band']\n",
    "age_df = pd.DataFrame.from_dict(age_dict, orient='index').rename(columns={'index': 'row', 0: 'count'})\n",
    "\n",
    "total = age_df['count'].sum()\n",
    "\n",
    "\n",
    "def calculate_percent(row, total):\n",
    "    row['%'] = (row['count']/total)*100\n",
    "    return row\n",
    "age_df = age_df.apply(lambda row: calculate_percent(row, total), axis=1)\n",
    "\n",
    "other_count = 0\n",
    "\n",
    "\n",
    "age_df.apply(lambda row: get_other_count(row, other_count), axis=1)\n",
    "age_df = age_df[age_df['count']>5]      \n",
    "\n",
    "age_df.append(pd.DataFrame(['-', other_count, 'Other']))\n",
    "age_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "instant-guest",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "saved-workshop",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}