CoronaPlots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CoronaPlots report\n",
    "\n",
    "This code focus on readability instead speed. \n",
    "\n",
    "> Note, you can remove all filters and others steps by replacing it by a simple loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "miG_foGmZ0Qk"
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PxgyzuJltQCs"
   },
   "source": [
    "---\n",
    "# Getting current date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KVMWv6G0lwg6"
   },
   "outputs": [],
   "source": [
    "# pytz.all_timezones to see all timezones\n",
    "from pytz import timezone # Defaul timezone it's ahead of Brasil(+)\n",
    "from datetime import datetime, date\n",
    "\n",
    "def isMonday():\n",
    "    return date.today().isoweekday() == 1\n",
    "\n",
    "# Note that changing linux localtime, doesn't affect Python\n",
    "BRASIL_TZ = timezone('America/Campo_Grande')\n",
    "DAY, MONTH, YEAR = datetime.now(BRASIL_TZ).strftime(\"%d %m %Y\").split()\n",
    "\n",
    "def getMonthName(monthStr:str, startUpper:bool = False) -> str:\n",
    "    '''\n",
    "    Need it when execute in different system's locale.\n",
    "\n",
    "    Args\n",
    "    ----\n",
    "    - `month`:\n",
    "        The current month\n",
    "    \n",
    "    Keyword Args\n",
    "    ------------\n",
    "    - `startUpper`:\n",
    "        A flag used to set the the type (upper or lower) of the first character\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    `string`\n",
    "        Month's names.\n",
    "    '''\n",
    "    month:int = int(monthStr)\n",
    "    monthName = ['janeiro',\n",
    "               'fevereiro',\n",
    "               'março',\n",
    "               'abril',\n",
    "               'maio',\n",
    "               'junho',\n",
    "               'julho',\n",
    "               'agosto',\n",
    "               'setembro',\n",
    "               'outubro',\n",
    "               'novembro',\n",
    "               'dezembro'\n",
    "    ]\n",
    "    monthstr:str = monthName[month-1] if month > 0 else monthName[-1]\n",
    "    m_up = monthstr[0].upper() + monthstr[1:]\n",
    "\n",
    "    return monthstr if not startUpper else m_up \n",
    "\n",
    "# Get month's name\n",
    "MONTH_NAME = getMonthName(MONTH, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Tsc7lqA3l_OB"
   },
   "source": [
    "# Starting logging\n",
    "[See this tip 'bout logging](https://docs.python.org/3/library/logging.html#logrecord-attributes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fo6SGvd_mBbD"
   },
   "outputs": [],
   "source": [
    "import logging as log\n",
    "log.basicConfig(\n",
    "    format='[%(asctime)s] : %(levelname)s: %(funcName)s : %(message)s', \n",
    "    datefmt='%H:%M:%S',\n",
    "    filename='logs/LOG_{}-{}-{}.log'.format(YEAR,MONTH,DAY),\n",
    "    level=log.DEBUG)\n",
    "log.info('Logging created w/ success!')\n",
    "log.debug('Default timezone: {}'.format(BRASIL_TZ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lq-OLd7_SIgj"
   },
   "source": [
    "# Login and Sheet load\n",
    "\n",
    "[O2auth (in use)](https://gspread.readthedocs.io/en/latest/oauth2.html) client.\n",
    "To use Google's API, you'll need to allow Google API in **[Google console](https://console.developers.google.com/iam-admin/projects)**. Also, you'll must create an business account too. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hIRm9cdvp0jR"
   },
   "source": [
    "## Login"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "plQAtizYczfB"
   },
   "outputs": [],
   "source": [
    "from oauth2client.service_account import ServiceAccountCredentials as Credentials\n",
    "import gspread # Sheets\n",
    "import os # environment\n",
    "\n",
    "# Login Constants\n",
    "SCOPE = ['https://www.googleapis.com/auth/spreadsheets.readonly']\n",
    "URL = os.environ.get(\"SPREADSHEET_URL\")\n",
    "\n",
    "# Create an Client\n",
    "GAUTH = Credentials.from_json_keyfile_name('credentials/nisis_credentials.json',SCOPE)\n",
    "# Auth the client\n",
    "GCLIENT = gspread.authorize(GAUTH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2xqDwIQnPTsV"
   },
   "outputs": [],
   "source": [
    "log.info('Client acquired with success!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PD5PyLhTpvER"
   },
   "source": [
    "## Sheet Load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "A7SjeJHZckME"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from numpy import nan as NaN\n",
    "import numpy as np\n",
    "\n",
    "def getSheetsNames(URL, gc):\n",
    "    '''\n",
    "    Get all tab's names from url (sheet)\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    URL: (str)\n",
    "    Url's sheet\n",
    "    gc: (GoogleClient)\n",
    "    Google client from gspread autenticated.\n",
    "\n",
    "    Return\n",
    "    ------\n",
    "    (list) Sheet's tab names.\n",
    "    '''\n",
    "    workSheets = GCLIENT.open_by_url(URL)\n",
    "    sheetsNames = [i.title for i in workSheets.worksheets()] # sheets names\n",
    "    return sheetsNames\n",
    "\n",
    "\n",
    "def getSheetValue(sheet_name, URL, gc, debug=False):\n",
    "    '''\n",
    "    Get pandas DF from sheet_name in WorkSheets. \n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    sheet_name: (string)\n",
    "    Name of sheet\n",
    "\n",
    "    Return\n",
    "    ------\n",
    "    (DataFrame) 2Dimensional sheet got it from one tab.\n",
    "\n",
    "    Examples\n",
    "    --------\n",
    "    >> all_dfs = list(map(getSheetValue,sheets))\n",
    "    >> list(map(lambda x: x.columns, all_dfs) )\n",
    "    >> df = pd.concat(all_dfs)\n",
    "    '''\n",
    "    wb    = GCLIENT.open_by_url(URL) # client open this url\n",
    "    sheet = wb.worksheet(sheet_name) # get value(tab) settled from cell above\n",
    "    data  = sheet.get_all_values() # get csv content from spreadsheet\n",
    "    df    = pd.DataFrame(data) # convert csv into DataFrame \n",
    "\n",
    "    df.columns = df.iloc[0] # Remove Id's columns (They're in fst row)\n",
    "    df = df.iloc[1:] # Ignore fst row\n",
    "\n",
    "    # If we have an empty column\n",
    "    df.dropna(axis='columns')\n",
    "    # If we have an empty row\n",
    "    df.dropna(axis='rows')\n",
    "    # Drop fst column (Index)\n",
    "    df.drop(df.columns[0], axis=1, inplace=True)\n",
    "\n",
    "    if debug:\n",
    "        log.debug('Sem situação: ', len(list(\n",
    "            filter(lambda x: type(x) is not str, df['Selecione a situação:']))))\n",
    "\n",
    "\n",
    "    ############################  Treating data ##################################\n",
    "    # Renaming columns\n",
    "    #   We rename column by column, 'cause if we do in this way, we won't have\n",
    "    #   problems with insertion of new columns. If we made this by replacing columns\n",
    "    #   list to a new one.\n",
    "    df.rename(columns={'Selecione a situação:': \"Situation\"}, inplace=True)\n",
    "    df.rename(columns={'Escolha a situação do caso confirmado:':\"SituationOfConfirmed\"}, inplace=True)\n",
    "    #df.rename(columns={'Houve internação?': \"Id\"}, inplace=True)\n",
    "    df.rename(columns={'Está monitorado pela central de vigilância da saúde? ': 'Monitoring'}, inplace=True)\n",
    "    df.rename(columns={'Houve internação?':'IsInterned'}, inplace=True)\n",
    "    df.rename(columns={'Sexo:':'Gender'}, inplace=True)\n",
    "    df.rename(columns={'Idade:':'Age'}, inplace=True)\n",
    "    df.rename(columns={'Bairro:':'Neighboorhood'}, inplace=True)\n",
    "    df.rename(columns={'Leito:':'HospitalClassifier'}, inplace=True)\n",
    "    df.rename(columns={'Escolha a situação do caso descartado:':'Discarted'}, inplace=True)\n",
    "    df.rename(columns={'Fatores de risco:':'RiskFactors'}, inplace=True)\n",
    "    df.rename(columns={'Semana epidemiológica':'EpidemicWeek'}, inplace=True)\n",
    "    df.rename(columns={'Data da internação:':'HospitalDate'}, inplace=True)\n",
    "\n",
    "    # Remove where Situation is empty -- In this dataframe, empty means that are duplicate\n",
    "    _filter = df['Situation'] != ''\n",
    "    df = df[_filter]\n",
    "\n",
    "    # Convert all dates in HospitalDate to format dd/mm/yyyy\n",
    "    # Note that we can't use Series.dt.date because we have\n",
    "    # empty fields as also 'PROFISSIONAL DE SAUDE', and furthermore\n",
    "    # 'FINALIZADO'.\n",
    "    def toFullYear(year):\n",
    "        if len(year)==8: # Means that are in format dd/mm/yy\n",
    "            year = year[:6] + '20' + year[6:]\n",
    "        return year\n",
    "    df['HospitalDate'] = df['HospitalDate'].apply(toFullYear)\n",
    "\n",
    "    # Convert to lower. We do this to minimize possible errors when making a string compare.\n",
    "    df['Situation'] = df['Situation'].str.lower()\n",
    "    df['Monitoring'] = df['Monitoring'].str.lower()\n",
    "    df['SituationOfConfirmed'] = df['SituationOfConfirmed'].str.lower()\n",
    "    df['HospitalClassifier'] = df['HospitalClassifier'].str.lower()\n",
    "    df['Gender'] = df['Gender'].str.lower()\n",
    "    df['RiskFactors'] = df['RiskFactors'].str.lower()\n",
    "    df['IsInterned'] = df['IsInterned'].str.lower()\n",
    "\n",
    "    # Fix: _nbh (empty and Spaced)\n",
    "    df['Neighboorhood'] = df['Neighboorhood'].str.strip() # Spaced\n",
    "    _filter = df['Neighboorhood'] == ''\n",
    "    df.loc[_filter, 'Neighboorhood'] = 'Sem Bairro' # Empty\n",
    "\n",
    "    # Fix: Convert str ages to int\n",
    "    _filter = df['Age'] == ''\n",
    "    df.loc[_filter, 'Age'] = 0 # put 0 in empty ages\n",
    "    df['Age'] = df['Age'].apply(lambda x: int(x)) # convert to int\n",
    "\n",
    "    # Fix: RiskFactors (empty and Spaced)\n",
    "    df['RiskFactors'] = df['RiskFactors'].str.strip() # Spaced\n",
    "    _filter = df['RiskFactors'] == ''\n",
    "    df.loc[_filter, 'RiskFactors'] = 'Não tem' # Empty\n",
    "\n",
    "    # Fix: Put N/A identifier in EpidemicWeek\n",
    "    _filter = np.array( df['EpidemicWeek'].str.isdigit(), dtype=np.bool)\n",
    "    df.loc[~_filter, 'EpidemicWeek'] = '#N/A' # Empty or #N/A\n",
    "    df.loc[_filter, 'EpidemicWeek'] = df.loc[_filter, 'EpidemicWeek'].apply(lambda x: int(x)) # Convert to int where is a number\n",
    "\n",
    "    df = df.reset_index(drop=True) # Drop removes old indexation \n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GM2pItluqNdo"
   },
   "outputs": [],
   "source": [
    "# Getting results\n",
    "sheetName = \"{}-{}-{}\".format(DAY,MONTH,YEAR)\n",
    "df = getSheetValue(sheetName, URL, GCLIENT)\n",
    "\n",
    "log.info('Tab \"{}\" oppened with success!'.format(sheetName))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GZONLH7KCieg"
   },
   "source": [
    "# Image and Copy Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ojdj0Es9dpE8"
   },
   "outputs": [],
   "source": [
    "# To import image in reportlab. Images are Pillow formats or BytesIO\n",
    "from reportlab.lib.utils import ImageReader\n",
    "\n",
    "from PIL import Image # Open png images\n",
    "from copy import deepcopy as dp # dataframe creation and manipulation permanent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-A7tuBAF__Vp"
   },
   "source": [
    "# Load Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eccMOT5OByIp"
   },
   "outputs": [],
   "source": [
    "def alpha2white(img):\n",
    "    # Create a white rgb background\n",
    "    _img = Image.new(\"RGBA\", img.size, \"WHITE\") \n",
    "    _img.paste(img, (0, 0), img)\n",
    "    _img.convert('RGB')\n",
    "    return _img.transpose(Image.FLIP_LEFT_RIGHT)\n",
    "\n",
    "# Draw method aim's to use ImageReader or path to object\n",
    "# we don't use here, 'cause of black background if alpha is 1\n",
    "boy  = ImageReader( alpha2white(Image.open('img/boy.png').rotate(180)) )\n",
    "girl = ImageReader( alpha2white(Image.open('img/girl.png').rotate(180)) )\n",
    "logo = ImageReader( Image.open('img/logo.png').rotate(180).transpose(Image.FLIP_LEFT_RIGHT) )\n",
    "# It's necessary rotate because PIL inverted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log.info('Images loaded successfully')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r5w_GH1ateMo"
   },
   "source": [
    "# Data analysis\n",
    "\n",
    "> In _Google sheets_ you can use COUNTIF functions to count ocurrences in a column:\n",
    ">```xls\n",
    "=COUNTIF(T1:T2000;\"SUSPEITO\")\n",
    "=SUBTOTAL(103;A2:A2000) # Count visible rows\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def similar(word1, word2, accept=False, caseSensitive=False, method='BuiltIn'):\n",
    "    '''\n",
    "    This method check similarity between strings. It can be used with\n",
    "    two ways. Using built-in method or leveinshtein implementation by\n",
    "    Antti Haapala. If use leveinshtein, need to\n",
    "        >>> pip install python-Levenshtein  \n",
    "    See\n",
    "    ---\n",
    "    https://rawgit.com/ztane/python-Levenshtein/master/docs/Levenshtein.html\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    word1: (string) To compare\n",
    "    word2: (string) To compare\n",
    "    accept: (int) If 0 will return percentual, else return true for value in percent\n",
    "    caseSensitive: (bool) Set false to disable\n",
    "    method: (string) 'BuiltIn' or 'Levenshtein'\n",
    "\n",
    "    Return\n",
    "    ------\n",
    "    Similarity in percentual if accept is False, otherwise,\n",
    "    True for percentual > accept\n",
    "    '''\n",
    "\n",
    "    if not caseSensitive:\n",
    "        word1 = word1.lower()\n",
    "        word2 = word2.lower()\n",
    "\n",
    "    if method == 'BuiltIn':\n",
    "        from difflib import SequenceMatcher\n",
    "        percent = SequenceMatcher(None, word1, word2).ratio()\n",
    "        return percent if not accept else percent>=accept\n",
    "\n",
    "    elif method == 'Levenshtein':\n",
    "        from Levenshtein import ratio\n",
    "        percent = ratio(word1, word2)\n",
    "        return percent if not accept else percent>=accept\n",
    "\n",
    "    else:\n",
    "        raise(Exception('Method not implemented.'))\n",
    "\n",
    "def applyFilter(df, l, word, col):\n",
    "    '''\n",
    "    Check in \"col\" of \"l\" situation, the amount of word who matches with \"word\" \n",
    "      with 0.7 similarity.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    df: (DataFrame) Data to analysis\n",
    "    l: (list) Bitset with lines to analysis.\n",
    "    word: (string) Word to analysis\n",
    "    col: (string) Column to search for.\n",
    "    \n",
    "    Return\n",
    "    ------\n",
    "    (int) Amount of ocurrences.\n",
    "\n",
    "    Example\n",
    "    -------\n",
    "    >> df = pd.DataFrame(['teste']*8, columns={'c1'})\n",
    "            col1\n",
    "      * 0\t1.0\n",
    "      * 1\t1.0\n",
    "      * 2\t1.0\n",
    "        3\t1.0\n",
    "        4\t1.0\n",
    "        5\t1.0\n",
    "        6\t1.0\n",
    "      * 7\t1.0\n",
    "    >> applyFilter(df, 3*[1]+4*[0]+[1], 'teste', 'c1')\n",
    "        4\n",
    "    >> 3*[1]+4*[0]+[1] == [1 1 1 0 0 0 0 1]\n",
    "    '''\n",
    "\n",
    "    def getValue(x):\n",
    "        if type(x) is not str:\n",
    "            return 0\n",
    "        else:\n",
    "            return similar(x,word,0.7)\n",
    "    return int(len(list( filter(getValue, df.loc[l, col]) )))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To be clear in variable manipulation, every var in this section will have\n",
    "# an d2a_ prefix (data to analysis). If it's a const will be UPPER_CASE\n",
    "\n",
    "AGES = [\n",
    "    'Não informado', \n",
    "    '1 a 9', \n",
    "    '10 a 19', \n",
    "    '20 a 29', \n",
    "    '30 a 39', \n",
    "    '40 a 49', \n",
    "    '50 a 59',\n",
    "    '>= 60'\n",
    "]\n",
    "\n",
    "# Risk factors\n",
    "DISEASES = [\n",
    "    'Doenças respiratórias crônicas descompensadas',\n",
    "    'Doenças cardíacas crônicas',\n",
    "    'Diabetes',\n",
    "    'Doenças renais crônicas em estágio avançado (graus 3,4 e 5)',\n",
    "    'Imunossupressão',\n",
    "    'Gestantes de alto risco',\n",
    "    'Portadores de doenças cromossômicas ou em estados de fragilidade imunológica (ex:.Síndrome de Down)',\n",
    "    'Não tem',\n",
    "    'Outros'\n",
    "]\n",
    "\n",
    "\n",
    "# Give a vector position according to AGES list\n",
    "def ageRange(age):\n",
    "    if age<1: return 0\n",
    "    if age>=1 and age<10: return 1\n",
    "    if age>=10 and age<20: return 2\n",
    "    if age>=20 and age<30: return 3\n",
    "    if age>=30 and age<40: return 4\n",
    "    if age>=40 and age<50: return 5\n",
    "    if age>=50 and age<60: return 6\n",
    "    return 7\n",
    "\n",
    "# Convert to percent\n",
    "def percentage(number, total):\n",
    "    return round(number*100/total, 1)\n",
    "\n",
    "\n",
    "# Vector of positions in dataframe corresponding to situations\n",
    "d2a_vConfirmed = np.array( df['Situation']=='confirmado', dtype=np.bool )\n",
    "d2a_vDunderI = np.array( df['Monitoring']=='obito em investigacao', dtype=np.bool ) # deaths under investigation\n",
    "d2a_vSuspect = np.array( df['Situation']=='suspeito', dtype=np.bool ) | d2a_vDunderI\n",
    "d2a_vDiscarted = np.array( df['Situation']=='descartado', dtype=np.bool )\n",
    "d2a_vCinterned = np.array( df['SituationOfConfirmed']=='internado', dtype=np.bool ) # Only for those confirmed interned\n",
    "d2a_vInterned = np.array( df['IsInterned']=='sim', dtype=np.bool ) # suspects, confirmed, discarted etc \n",
    "# After talk to Patrícia, she told me that she itself change those ones who are\n",
    "# interned, so, we actually must ignore those informations in google forms, and attempt\n",
    "# just to search of values in fields \n",
    "# Only for those suspects interned\n",
    "d2a_vSinterned = np.array( df['Monitoring']=='internado', dtype=np.bool ) & d2a_vSuspect # We can't use loc, cause it will raise only true ones\n",
    "d2a_vHospitals = np.array( df['Hospital'].str.len() > 4, dtype=np.bool) # Find hospitals with str lenght > 4 (Belo Horizonte)\n",
    "d2a_vMonitoring = np.array(df['Monitoring']=='sim', dtype=np.bool ) # Those that are not in hospital\n",
    "\n",
    "# Total of ..\n",
    "d2a_TofConfirmed = np.count_nonzero(d2a_vConfirmed) # Confirmed cases\n",
    "d2a_TofDiscarted = np.count_nonzero(d2a_vDiscarted) # Discarted cases\n",
    "d2a_TofSuspect = np.count_nonzero(d2a_vSuspect)     # Suspects cases\n",
    "d2a_TofDunderI = np.count_nonzero(d2a_vDunderI)     # Total of deaths under inestigation\n",
    "\n",
    "# Total of Confirmed in ..\n",
    "_vBH, _vITA = d2a_vCinterned&d2a_vHospitals, d2a_vCinterned&~d2a_vHospitals               # Auxiliar vectors of hospital and Confirmed interneds\n",
    "d2a_TofCnurseryBH = applyFilter(df, _vBH,'enfermaria','HospitalClassifier')               #  in nursery in BH\n",
    "d2a_TofCnurseryITA = applyFilter(df, _vITA,'enfermaria','HospitalClassifier')             #  in nursery in ita\n",
    "d2a_TofCuti = applyFilter(df, _vITA,'ti','HospitalClassifier')                            #  in uti in Ita\n",
    "d2a_TofCcti = applyFilter(df, _vBH,'ti','HospitalClassifier')                             #  in uti in BH\n",
    "d2a_TofCrecover = applyFilter(df, d2a_vConfirmed,'recuperado','SituationOfConfirmed')     #  that recovered\n",
    "d2a_TofChome = applyFilter(df, d2a_vConfirmed,'amento domiciliar','SituationOfConfirmed') #  that are in home\n",
    "d2a_TofCdead = applyFilter(df, d2a_vConfirmed,'óbito','SituationOfConfirmed')             #  that are dead\n",
    "d2a_TofCfemale = applyFilter(df, d2a_vConfirmed,'f','Gender')                             #  were gender is\n",
    "d2a_TofCmale = applyFilter(df, d2a_vConfirmed,'m','Gender')                               #  were gender is\n",
    "d2a_TofCdiseases = [applyFilter(df, d2a_vConfirmed, it,'RiskFactors') for it in DISEASES]\n",
    "_aux = sum(d2a_TofCdiseases)\n",
    "d2a_TofCdiseases = [percentage(it,_aux) for it in d2a_TofCdiseases]                       #  according with diseases (in percentage)\n",
    "\n",
    "# Total of Suspects in ...\n",
    "d2a_TofSmonitor = np.count_nonzero(d2a_vMonitoring & d2a_vSuspect)                  # monitoring\n",
    "d2a_TofSnursery = applyFilter(df, d2a_vSinterned,'enfermaria','HospitalClassifier') # in hospital (nursery)\n",
    "d2a_TofSuti = applyFilter(df, d2a_vSinterned,'uti','HospitalClassifier')            # in hospital (uti)\n",
    "d2a_TofSfemale = applyFilter(df, d2a_vSuspect,'f','Gender')                         # were gender is\n",
    "d2a_TofSmale = applyFilter(df, d2a_vSuspect,'m','Gender')                           # were gender is\n",
    "\n",
    "\n",
    "# Total of (Suspects and Confirmed) according with diseases (in percentage)\n",
    "d2a_TofCSdiseases = [applyFilter(df, d2a_vConfirmed | d2a_vSuspect, it,'RiskFactors') for it in DISEASES]\n",
    "_aux              = sum(d2a_TofCSdiseases)\n",
    "d2a_TofCSdiseases = [percentage(it,_aux) for it in d2a_TofCSdiseases]\n",
    "\n",
    "\n",
    "# Total of Discarted deaths\n",
    "d2a_TofDdeaths   = applyFilter(df, d2a_vDiscarted,'óbito','Discarted')\n",
    "\n",
    "\n",
    "\n",
    "# Create Vectors of Ages corresponding of situations\n",
    "d2a_vSage         = [0]*len(AGES) # Suspect ages\n",
    "d2a_vCage         = [0]*len(AGES) # Confirmed\n",
    "\n",
    "# Week\n",
    "d2a_vCSweekName = list(set(df['EpidemicWeek']))\n",
    "d2a_vCSweekName.remove('#N/A') # With this we force '#N/A' to be the first in list\n",
    "d2a_vCSweekName = ['#N/A'] + d2a_vCSweekName # we use this trick to force positions below\n",
    "d2a_vCSweekValue = [0]*len(d2a_vCSweekName) # same idea as ages\n",
    "\n",
    "# Populate vectors of week and ages\n",
    "for it in df.index:\n",
    "    if d2a_vSuspect[it]:\n",
    "        d2a_vSage[ ageRange( df.loc[it,'Age'] ) ] += 1\n",
    "        _week = df.loc[it, 'EpidemicWeek']\n",
    "        if _week =='#N/A':\n",
    "            _week = 0\n",
    "        # force position from set above (start to count at 10th week)\n",
    "        d2a_vCSweekValue[_week-9 if _week>0 else 0] += 1\n",
    "\n",
    "    if d2a_vConfirmed[it]:\n",
    "        d2a_vCage[ ageRange(df.loc[it,'Age']) ] += 1\n",
    "        _week = df.loc[it, 'EpidemicWeek']\n",
    "        if _week =='#N/A':\n",
    "            _week = 0\n",
    "        # Note that week value to\"1'\\n\".strip()ok both situations.\n",
    "        d2a_vCSweekValue[_week-9 if _week>0 else 0] += 1 \n",
    "        \n",
    "# Where don't have an NHD the type is NaN, due that, we can't access it\n",
    "_nbh = []\n",
    "for i in set(df['Neighboorhood']): \n",
    "    conf  = len(list(filter(lambda x: x, df.loc[d2a_vConfirmed, 'Neighboorhood']==i)))\n",
    "    susp  = len(list(filter(lambda x: x, df.loc[d2a_vSuspect, 'Neighboorhood']==i)))\n",
    "    #anali = len(list(filter(lambda x: x, df.loc[d2a_vAnalysis, 'Neighboorhood']==i)))\n",
    "    _nbh.append({ 'Neighboorhood': i, 'qtdSuspect': susp, 'qtdConf': conf})#, 'qtdAnalis': anali})\n",
    "# Sort by ascending order\n",
    "d2a_vNeighboorhood = sorted(_nbh, key=lambda k: k['qtdConf'], reverse=True)\n",
    "_aux = [i for i in d2a_vNeighboorhood if i['qtdSuspect'] or i['qtdConf']]\n",
    "d2a_vNeighboorhood = _aux\n",
    "\n",
    "# Now we must access a stored data which refers to oldiest reports\n",
    "# This is needed, because the sheetsheet change the current situation\n",
    "# over time, losing the oldiest suspects, e.g.\n",
    "_cdate = '{}-{}-{}'.format(YEAR, MONTH, DAY)\n",
    "\n",
    "# Import database's library\n",
    "import sqlite3\n",
    "\n",
    "# Connect to sqlite database used to store the data of the past mondays\n",
    "database = sqlite3.connect(\"others/database.sqlite\")\n",
    "\n",
    "# Load the data into a DataFrame\n",
    "d2a_dfCStimeline = pd.read_sql_query(\n",
    "    \"SELECT * from Covid_and_Suspects_timeline\", \n",
    "    database,\n",
    "    index_col=\"Id\"\n",
    ")\n",
    "\n",
    "# Update the database if it's monday\n",
    "if isMonday():\n",
    "    # If the date already exist in df, update it\n",
    "    if _cdate in d2a_dfCStimeline['Data'].tolist():\n",
    "        _pos = d2a_dfCStimeline['Data']==_cdate\n",
    "        d2a_dfCStimeline.loc[_pos, 'Sindrome'] = np.int64(d2a_TofSuspect)\n",
    "        d2a_dfCStimeline.loc[_pos, 'Covid'] = np.int64(d2a_TofConfirmed)\n",
    "    # If don't (runned at first time in the monday), create a new row\n",
    "    else:\n",
    "        d2a_dfCStimeline = d2a_dfCStimeline.append({\n",
    "            'Data': _cdate,\n",
    "            'Sindrome': np.int64(d2a_TofSuspect),\n",
    "            'Covid': np.int64(d2a_TofConfirmed)\n",
    "            },\n",
    "            ignore_index=True)\n",
    "\n",
    "\n",
    "# Write the dataframe d2a_dfCStimeline to the database\n",
    "d2a_dfCStimeline.to_sql(\n",
    "    \"Covid_and_Suspects_timeline\", # Table name\n",
    "    database,                      # Database name\n",
    "    if_exists=\"replace\",           # Replace table if exist\n",
    "    index_label=\"Id\",              # Index name\n",
    "    index=True                     # Enable index name\n",
    ")\n",
    "\n",
    "# Close DB connection\n",
    "database.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Logs\n",
    "log.debug('Data: df.shape[0] → {}'.format(df.shape[0]))\n",
    "log.info('Data analysis')\n",
    "# Inserting all data in log\n",
    "log.debug('Data: AGES → {}'.format(AGES))\n",
    "log.debug('Data: DISEASES → {}'.format(DISEASES))\n",
    "log.debug('Data: d2a_vConfirmed → {}'.format(d2a_vConfirmed))\n",
    "log.debug('Data: d2a_vDunderI → {}'.format(d2a_vDunderI))\n",
    "log.debug('Data: d2a_vSuspect → {}'.format(d2a_vSuspect))\n",
    "log.debug('Data: d2a_vDiscarted → {}'.format(d2a_vDiscarted))\n",
    "log.debug('Data: d2a_vCinterned → {}'.format(d2a_vCinterned))\n",
    "log.debug('Data: d2a_vSinterned → {}'.format(d2a_vSinterned))\n",
    "log.debug('Data: d2a_vMonitoring → {}'.format(d2a_vMonitoring))\n",
    "log.debug('Data: d2a_TofConfirmed → {}'.format(d2a_TofConfirmed))\n",
    "log.debug('Data: d2a_TofDiscarted → {}'.format(d2a_TofDiscarted))\n",
    "log.debug('Data: d2a_TofSuspect → {}'.format(d2a_TofSuspect))\n",
    "log.debug('Data: d2a_TofDunderI → {}'.format(d2a_TofDunderI))\n",
    "log.debug('Data: d2a_TofCnurseryBH → {}'.format(d2a_TofCnurseryBH))\n",
    "log.debug('Data: d2a_TofCnurseryITA → {}'.format(d2a_TofCnurseryITA))\n",
    "log.debug('Data: d2a_TofCuti → {}'.format(d2a_TofCuti))\n",
    "log.debug('Data: d2a_TofCcti → {}'.format(d2a_TofCcti))\n",
    "log.debug('Data: d2a_TofCrecover → {}'.format(d2a_TofCrecover))\n",
    "log.debug('Data: d2a_TofChome → {}'.format(d2a_TofChome))\n",
    "log.debug('Data: d2a_TofCdead → {}'.format(d2a_TofCdead))\n",
    "log.debug('Data: d2a_TofSmonitor → {}'.format(d2a_TofSmonitor))\n",
    "log.debug('Data: d2a_TofDdeaths → {}'.format(d2a_TofDdeaths))\n",
    "log.debug('Data: d2a_TofSnursery → {}'.format(d2a_TofSnursery))\n",
    "log.debug('Data: d2a_TofSuti → {}'.format(d2a_TofSuti))\n",
    "log.debug('Data: d2a_TofSfemale → {}'.format(d2a_TofSfemale))\n",
    "log.debug('Data: d2a_TofSmale → {}'.format(d2a_TofSmale))\n",
    "log.debug('Data: d2a_TofCfemale → {}'.format(d2a_TofCfemale))\n",
    "log.debug('Data: d2a_TofCmale → {}'.format(d2a_TofCmale))\n",
    "log.debug('Data: d2a_vSage → {}'.format(d2a_vSage))\n",
    "log.debug('Data: d2a_vCage → {}'.format(d2a_vCage))\n",
    "log.debug('Data: d2a_TofCdiseases → {}'.format(d2a_TofCdiseases))\n",
    "log.debug('Data: d2a_TofCSdiseases → {}'.format(d2a_TofCSdiseases))\n",
    "log.debug('Data: d2a_vCSweekName → {}'.format(d2a_vCSweekName))\n",
    "log.debug('Data: d2a_vCSweekValue → {}'.format(d2a_vCSweekValue))\n",
    "log.debug('Data: d2a_dfCStimeline.shape[0] → {}'.format(d2a_dfCStimeline.shape[0]))\n",
    "log.debug('Data: isMonday → {}'.format(isMonday()))\n",
    "log.debug('Data: d2a_vNeighboorhood → {}'.format(d2a_vNeighboorhood))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w6_Ikwe6tmL-"
   },
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "QsD4wWZlm_X9",
    "outputId": "7fdc9680-a254-4a70-81c3-eb39132afce0"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns # Change color plot\n",
    "from io import BytesIO # Image buff\n",
    "\n",
    "sns.set_style('darkgrid')\n",
    "\n",
    "def barPlot(x,y, siz, palette=\"Oranges\"):\n",
    "    fig = plt.figure( figsize=siz )\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",
    "      labelbottom=False) # labels along the bottom edge are off\n",
    "    ax = sns.barplot(x=x, y=y, palette=palette)\n",
    "\n",
    "    _currSpace = ax.get_xticks()\n",
    "    _currSpace = _currSpace[1] - _currSpace[0]\n",
    "    plt.xticks(np.arange(0, max(x)+_currSpace, _currSpace))\n",
    "\n",
    "    # Create annotions marks using total amount of infected\n",
    "    maxX = max(x)\n",
    "    _y = 0\n",
    "    for i in x:\n",
    "        ax.text(i + maxX/100, _y, str(i))\n",
    "        _y+=1\n",
    "\n",
    "    fig.tight_layout() # Remove extra paddings\n",
    "    # Convert fig img to buffer img\n",
    "    buff =  BytesIO()\n",
    "    fig.savefig(buff, format='PNG')\n",
    "    buff.seek(0)\n",
    "    buff = Image.open(buff).rotate(180).transpose(Image.FLIP_LEFT_RIGHT)\n",
    "    return ImageReader( buff )\n",
    "\n",
    "\n",
    "def linePlot(y,x, siz,palette=\"Oranges\"):\n",
    "    fig = plt.figure( figsize=siz )\n",
    "    plt.plot(x,y, marker='o', color='darkred', linewidth=2, markersize=12)\n",
    "    # sns.set_palette(palette)\n",
    "\n",
    "    fig.tight_layout() # Remove extra paddings\n",
    "    # Convert fig img to buffer img\n",
    "    buff =  BytesIO()\n",
    "    fig.savefig(buff, format='PNG')\n",
    "    buff.seek(0)\n",
    "    buff = Image.open(buff).rotate(180).transpose(Image.FLIP_LEFT_RIGHT)\n",
    "    return ImageReader( buff )\n",
    "\n",
    "\n",
    "def linePlot2(df, y, siz, ftsize='small'):\n",
    "    from math import floor\n",
    "\n",
    "    fig = plt.figure( figsize=siz )\n",
    "\n",
    "    plt.plot(\n",
    "        range(0, df.shape[0]),\n",
    "        df[y].tolist(), \n",
    "        marker='o', \n",
    "        color='darkred', \n",
    "        linewidth=2, \n",
    "        markersize=5\n",
    "    )\n",
    "    \n",
    "    spacingY = max(df[y])/10\n",
    "    xStart = 0\n",
    "    xSpace = floor( (df.shape[0] - xStart)/10 ) # It'll give me the spacing\n",
    "    vxSpace = [i for i in range(xStart, df.shape[0], 1) ]\n",
    "    vxNames = []\n",
    "    \n",
    "    # Convert into word like\n",
    "    for i in df.loc[ vxSpace, 'Data' ].tolist():\n",
    "        _c = i.split('-')\n",
    "        vxNames.append(\"{}/{}\".format(_c[-1], getMonthName(_c[1])) )\n",
    "    \n",
    "    plt.xticks(vxSpace, vxNames, rotation=90)\n",
    "    \n",
    "    # Put number y values as annotations\n",
    "    for i in range(df.shape[0]):\n",
    "        _v = df.loc[i,y]\n",
    "        plt.text(\n",
    "          i, \n",
    "          _v+spacingY, \n",
    "          str(_v),\n",
    "          fontsize=ftsize,\n",
    "          rotation=90,\n",
    "          verticalalignment='baseline', \n",
    "          horizontalalignment='center'\n",
    "        )\n",
    "    \n",
    "    # Grid Y positions numbers\n",
    "    maxY = max(df[y])\n",
    "    plt.yticks( \n",
    "        range(0,maxY+300, 100) \n",
    "    )\n",
    "\n",
    "    fig.tight_layout() # Remove extra paddings\n",
    "    # Convert fig img to buffer img\n",
    "    buff =  BytesIO()\n",
    "    fig.savefig(buff, format='PNG')\n",
    "    buff.seek(0)\n",
    "    buff = Image.open(buff).rotate(180).transpose(Image.FLIP_LEFT_RIGHT)\n",
    "    return ImageReader( buff )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating\n",
    "graphic_C           = barPlot(d2a_vCage, AGES, (7,5))\n",
    "graphic_S           = barPlot(d2a_vSage, AGES, (7,5))\n",
    "graphic_Cdiseases   = barPlot(d2a_TofCdiseases, DISEASES, (15,5))\n",
    "graphic_CSdiseases  = barPlot(d2a_TofCSdiseases, DISEASES, (15,5))\n",
    "graphic_CSweek      = linePlot(d2a_vCSweekValue, d2a_vCSweekName, (15,5))\n",
    "graphic_Ctimeline   = linePlot2(d2a_dfCStimeline, 'Covid', (15,5) )\n",
    "graphic_Stimeline   = linePlot2(d2a_dfCStimeline, 'Sindrome', (15,5) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "47pfzsradkK4"
   },
   "source": [
    "# PDF Report"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from reportlab import __version__\n",
    "# Canvas are used to draw in pdf (When U won't to create a document template)\n",
    "from reportlab.pdfgen import canvas\n",
    "# Tool to create colors models in reportlab. Colors as weel\n",
    "from reportlab.lib import colors as rlabColors\n",
    "# Tools to import family fonts\n",
    "from reportlab.pdfbase import pdfmetrics\n",
    "from reportlab.pdfbase.ttfonts import TTFont"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Font family and others settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "################ Font family and Colors ########################\n",
    "# https://fontawesome.com/cheatsheet/free/solid\n",
    "pdfmetrics.registerFont(TTFont('FontAwesomeS', 'fonts/FontAwesome_5_' + 'Solid.ttf'))\n",
    "pdfmetrics.registerFont(TTFont('FontAwesomeB', 'fonts/FontAwesome_5_' + 'Brands.ttf'))\n",
    "pdfmetrics.registerFont(TTFont('Montserrat','fonts/Montserrat-'+'Regular.ttf'))\n",
    "pdfmetrics.registerFont(TTFont('Montserratb','fonts/Montserrat-'+'Bold.ttf'))\n",
    "pdfmetrics.registerFont(TTFont('Montserrati','fonts/Montserrat-'+'Italic.ttf'))\n",
    "pdfmetrics.registerFont(TTFont('Montserratbi','fonts/Montserrat-'+'BoldItalic.ttf'))\n",
    "pdfmetrics.registerFontFamily(\n",
    "    'Montserrat',\n",
    "    normal='Montserrat',\n",
    "    bold='Montserratb',\n",
    "    italic='Montserrati',\n",
    "    boldItalic='Montserratbi')\n",
    "\n",
    "# Colors not def'ed in rlabColors\n",
    "myColors = {\n",
    "    'HeadOrange': rlabColors.toColor('rgb(209,64,19)'),\n",
    "    'Head2Orange': rlabColors.toColor('rgb(255,160,153)'),\n",
    "    'HeadBlue': rlabColors.toColor('rgb(20,13,93)'),\n",
    "    'Head2Blue': rlabColors.toColor('rgb(0,171,153)'),\n",
    "    'BlueGray': rlabColors.toColor('rgb(195,210,231)'),\n",
    "    'Green':  rlabColors.toColor('rgb(179,111,90)'),\n",
    "    'GreenD':  rlabColors.toColor('rgb(0,255,0)'),\n",
    "    'BlueFB': rlabColors.toColor('rgb(9,37,83)'),\n",
    "    'IceWhite': rlabColors.toColor('rgb(233,233,233)')\n",
    "} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default configs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keywords = ['PDF report','Corona', 'Corona vírus', 'vírus', 'COVID19']\n",
    "progVers = '2.0'\n",
    "author   = 'Pedro Augusto C Santos'\n",
    "subject  = 'NISIS - SMS de Itabira'\n",
    "creator  = 'ReportLab v'+__version__\n",
    "producer = 'www.reportlab.com'\n",
    "\n",
    "xPos = 0\n",
    "yPos = 0\n",
    "page = '' # just to initialize the variable\n",
    "\n",
    "# To the settings before I just need a way to propagate changes\n",
    "# without rewrite everything. Furthermore, I'm using the characteristics\n",
    "# of python, to search variables defined before to minimize the number of\n",
    "# parameters that I would to put in Class, or either in a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pdf generic functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pdfDrawLink(url, x, y, width, height, color=False):\n",
    "    '''\n",
    "    This function fix the link problem with the coordinates system.\n",
    "\n",
    "    Globals\n",
    "    -------\n",
    "    page: (reportlab Canvas) Pdf itself.\n",
    "    pgDim: (dict) 'w'=page_width, 'h'=page_height.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    url: (str) Link to webpage. Consider to use \"https://{}\".format(url), \n",
    "                otherwise, will try to link with file.\n",
    "    x: (int) X position.\n",
    "    y: (int) Y position.\n",
    "    width: (int) Size dimension.\n",
    "    height: (int) Size dimension.\n",
    "    color: (bool) If true, draws a rectangle equivalent to the area where the link are.\n",
    "    '''\n",
    "    global page, pgDim\n",
    "\n",
    "    if color:\n",
    "        page.setFillColor(myColors['Green'])\n",
    "        page.rect(x,y,width,height,fill=1,stroke=0)\n",
    "    \n",
    "    y = pgDim['h'] - y\n",
    "    \n",
    "    page.linkURL(\n",
    "        url,\n",
    "        (x, y, x+width, y-height),\n",
    "        thickness=0\n",
    "        # relative=1, # This doesn't nothing. \n",
    "        # In theory, this should be capable to use page properties instead default coordinate system (bottom up, left right)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pdf_Start(fileName):\n",
    "    global pgDim, xPos, yPos, page\n",
    "\n",
    "    xPos = 0\n",
    "    yPos = 0\n",
    "\n",
    "    page = canvas.Canvas(\n",
    "        fileName,\n",
    "        pagesize=(pgDim['w'],pgDim['h']),\n",
    "        bottomup = 0,\n",
    "        pageCompression=0,\n",
    "        verbosity=0,\n",
    "        encrypt=None\n",
    "    )\n",
    "    page.setProducer(producer)\n",
    "    page.setKeywords(keywords)\n",
    "    page.setCreator(creator)\n",
    "    page.setAuthor(author)\n",
    "    page.setSubject(subject)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setTitle(t):\n",
    "    global page\n",
    "    \n",
    "    page.setTitle(t)\n",
    "    page.setFillColor(rlabColors.white)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Header"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putHeader(c1, c2):\n",
    "    global page, yPos\n",
    "\n",
    "    # Header\n",
    "    page.setFillColor(myColors[c1])\n",
    "    page.rect(0,0,pgDim['w'], 148, stroke=0, fill=1)\n",
    "    # Sub header\n",
    "    page.setFillColor(myColors[c2])\n",
    "    page.rect(0,148,pgDim['w'], 47, stroke=0, fill=1)\n",
    "\n",
    "    page.setFont(\"Montserrat\",36)\n",
    "    page.setFillColor(rlabColors.white)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2, \n",
    "        105.2,\n",
    "        \"BOLETIM EPIDEMIOLÓGICO\"\n",
    "    )\n",
    "\n",
    "    page.setFont(\"Montserrat\",13)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        130.6,\n",
    "        \"COVID-19: Doença causada pelo Novo Coronavírus\"\n",
    "    )\n",
    "\n",
    "    page.setFont(\"Montserratb\",13)\n",
    "    page.drawString(\n",
    "        13, \n",
    "        173.6,\n",
    "        \"{} de {} de {}\".format(DAY,MONTH_NAME,YEAR)\n",
    "    )\n",
    "\n",
    "    page.drawString(\n",
    "        570, \n",
    "        173.6,\n",
    "        \"Secretaria de Saúde de Itabira\"\n",
    "    )\n",
    "\n",
    "    yPos = 200 # 195 \n",
    "    # Before this point, everything must use yPos parameter to position Y coords\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Emphasis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putEmphasis():\n",
    "    global page, yPos\n",
    "\n",
    "    def dots(page, x, y, s, k):\n",
    "        '''\n",
    "        Parameters\n",
    "        ----------\n",
    "        page: (reportlab) (where to modify)\n",
    "        x: (int) x start pos\n",
    "        y: (int) y start pos\n",
    "        s: (int) y number of dots\n",
    "        x: (int) x number of dots\n",
    "        '''\n",
    "        i,j = 1,0\n",
    "        while i <= s:\n",
    "            page.circle(x, y + 8*i, 2, stroke=0, fill=1)\n",
    "            i+=1\n",
    "        while j <= k:\n",
    "            page.circle(x + 8*j, y + 8*i, 2, stroke=0, fill=1)\n",
    "            j+=1\n",
    "        \n",
    "    # Rectangles and Dots (LEFT)\n",
    "    page.setFillColor(myColors['BlueFB'])\n",
    "    page.roundRect(14, yPos + 75,219, 112, 15, 0, 1)\n",
    "    dots(page, 30, yPos + 187, 6, 1)\n",
    "    dots(page, 30, yPos + 235, 6, 3)\n",
    "    dots(page, 30, yPos + 235+48, 11, 3)\n",
    "    page.setFont('Montserrat',18)\n",
    "    page.drawString(115, yPos + 239,'PESSOA(S) EM')\n",
    "    page.drawString(115, yPos + 255,'MONITORAMENTO')\n",
    "    page.drawString(115, yPos + 285, 'PESSOA(S)')\n",
    "    page.drawString(115, yPos + 301, 'HOSPITALIZADA(S)')\n",
    "    page.drawString(115, yPos + 239+48+88,'ÓBITO(S) EM')\n",
    "    page.drawString(115, yPos + 255+48+88,'INVESTIGAÇÃO')\n",
    "    page.setFont('Montserrat',32)\n",
    "    page.drawCentredString(75, yPos + 251, str(d2a_TofSmonitor))\n",
    "    page.drawCentredString(75, yPos + 300, str(d2a_TofSnursery + d2a_TofSuti))\n",
    "    page.drawCentredString(75, yPos + 300+88, str(d2a_TofDunderI))\n",
    "    page.setFont('Montserrat',18)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(108, yPos + 327, str(d2a_TofSnursery))\n",
    "    page.drawCentredString(108, yPos + 345, str(d2a_TofSuti))\n",
    "    page.setFont('Montserrat',12)\n",
    "    dots(page, 70, yPos + 300, 2, 2)\n",
    "    dots(page, 70, yPos + 316, 2, 2)\n",
    "    page.drawString(98+20, yPos + 325, 'enfermaria')\n",
    "    page.drawString(98+20, yPos + 343, 'em UTI')\n",
    "\n",
    "    # Rectangles and DOTS (MIDDLE)\n",
    "    page.setFillColor(rlabColors.red)\n",
    "    page.roundRect(288 - 10, yPos + 75, 219, 112, 15, 0, 1)\n",
    "    dots(page, 330 - 10, yPos + 187, 4, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 8, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 12, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 16, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 20, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 24, 2)\n",
    "    dots(page, 330 - 10, yPos + 187, 28, 2)\n",
    "    page.setFont('Montserrat',32)\n",
    "    page.drawCentredString(395 - 20, yPos + 240, str(d2a_TofCrecover))\n",
    "    page.drawCentredString(395 - 20, yPos + 270, str(d2a_TofChome))\n",
    "    page.drawCentredString(395 - 20, yPos + 300, str(d2a_TofCdead))\n",
    "    page.drawCentredString(395 - 20, yPos + 335, str(d2a_TofCnurseryITA))\n",
    "    page.drawCentredString(395 - 20, yPos + 365, str(d2a_TofCuti))\n",
    "    page.drawCentredString(395 - 20, yPos + 395, str(d2a_TofCnurseryBH))\n",
    "    page.drawCentredString(395 - 20, yPos + 395+30, str(d2a_TofCcti))\n",
    "    page.setFont('Montserrat',12)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawString(428 - 10, yPos + 230, 'recuperado(s)')\n",
    "    page.drawString(428 - 10, yPos + 255, 'em isolamento domiciliar') #\n",
    "    page.drawString(448 - 10, yPos + 268, 'monitorado')               #\n",
    "    page.drawString(428 - 10, yPos + 293, 'óbito(s) confirmado(os)')\n",
    "    page.drawString(428 - 10, yPos + 325, 'hospitalizado(s) em enfermaria em Itabira')\n",
    "    page.drawString(428 - 10, yPos + 355, 'hospitalizado(s) em UTI em Itabira')\n",
    "    page.drawString(428 - 10, yPos + 385, 'hospitalizado(s) em enfermaria em outra cidade')\n",
    "    page.drawString(428 - 10, yPos + 385+30, 'hospitalizado(s) em UTI em outra cidade')\n",
    "    \n",
    "\n",
    "    # Rectangles and DOTS (RIGHT)\n",
    "    page.setFillColor(myColors['GreenD'])\n",
    "    page.roundRect(563, yPos + 75, 219, 112, 15, 0, 1)\n",
    "    dots(page, 590 + 15, yPos + 212, 5, 1)\n",
    "    page.setFont('Montserrat',32)\n",
    "    page.drawCentredString(620 + 15, yPos + 272, str(d2a_TofDdeaths))\n",
    "    page.setFont('Montserrat',12)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawString(563 + 15, yPos + 200, 'Testaram negativo para Covid-19')\n",
    "    page.drawString(573 + 15, yPos + 210, 'ou positivo para outra doença')\n",
    "    page.drawString(635 + 20, yPos + 265, 'óbito(s) descartados')\n",
    "\n",
    "\n",
    "    # Text over rectangles\n",
    "    page.setFont(\"Montserrat\",18)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        14 + 219/2,\n",
    "        178 + 3.6*12,\n",
    "        \"Notificações de\"\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        14 + 219/2,\n",
    "        178 + 3.6*17,\n",
    "        \"Síndrome Respiratória\"\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        14 + 219/2,\n",
    "        178 + 3.6*22,\n",
    "        \"não específicada\"\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        288 + 219/2, \n",
    "        178 + 3.6*17,\n",
    "        \"Casos Confirmados\"\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        563 + 219/2, \n",
    "        178 + 3.6*17,\n",
    "        \"Casos Descartados\"\n",
    "    )\n",
    "\n",
    "    # Text inside rectangles\n",
    "    page.setFont(\"Montserratbi\",48)\n",
    "    page.setFillColor(rlabColors.white)\n",
    "    page.drawCentredString(\n",
    "        123.5, \n",
    "        yPos + 153.6,\n",
    "        str(d2a_TofSuspect)\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        397.5,\n",
    "        yPos + 153.6,\n",
    "        str(d2a_TofConfirmed)\n",
    "    )\n",
    "    page.drawCentredString(\n",
    "        672.5,\n",
    "        yPos + 153.6,\n",
    "        str(d2a_TofDiscarted)\n",
    "    )\n",
    "\n",
    "    yPos = 700\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perfil Epidemiológico Dos Casos De Síndrome Respiratória Não Específicada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecOne():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        \"PERFIL EPIDEMIOLÓGICO DOS CASOS DE SÍNDROME\")\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos + 30,\n",
    "        \"RESPIRATÓRIA NÃO ESPECÍFICADA\")\n",
    "\n",
    "    # Subtitle\n",
    "    page.setFont(\"Montserrat\",14)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        165,\n",
    "        yPos + 68,\n",
    "        \"Por sexo\")\n",
    "    page.drawCentredString(\n",
    "        555,\n",
    "        yPos + 68,\n",
    "        \"Por faixa etária\")\n",
    "\n",
    "    # Draw boy, girl and plot\n",
    "    page.drawImage(boy, 190, yPos + 88, 35,114)\n",
    "    page.drawImage(girl, 101, yPos + 88, 40,114)\n",
    "    page.drawImage(graphic_S, 400, yPos + 88, 350,250)\n",
    "\n",
    "    # Draw boy and girl numbers\n",
    "    page.setFont(\"Montserrat\",14)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "\n",
    "    page.drawCentredString(\n",
    "        120,\n",
    "        yPos + 240,\n",
    "        str(d2a_TofSfemale))\n",
    "    page.drawCentredString(\n",
    "        207,\n",
    "        yPos + 240,\n",
    "        str(d2a_TofSmale))\n",
    "\n",
    "    yPos += 450\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perfil epidemiológico casos confirmados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecTwo():\n",
    "    global page, yPos\n",
    "    \n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        \"PERFIL EPIDEMIOLÓGICO DOS CASOS CONFIRMADOS\")\n",
    "\n",
    "    # Subtitle\n",
    "    page.setFont(\"Montserrat\",14)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        165,\n",
    "        yPos + 68,\n",
    "        \"Por sexo\")\n",
    "    page.drawCentredString(\n",
    "        555,\n",
    "        yPos + 68,\n",
    "        \"Por faixa etária\")\n",
    "\n",
    "    # Draw boy, girl and plot\n",
    "    page.drawImage(boy, 190, yPos + 88, 35,114)\n",
    "    page.drawImage(girl, 101, yPos + 88, 40,114)\n",
    "    page.drawImage(graphic_C, 400, yPos + 88, 350,250)\n",
    "\n",
    "    # Draw boy and girl numbers\n",
    "    page.setFont(\"Montserrat\",14)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        120,\n",
    "        yPos + 240,\n",
    "        str(d2a_TofCfemale))\n",
    "    page.drawCentredString(\n",
    "        207,\n",
    "        yPos + 240,\n",
    "        str(d2a_TofCmale))\n",
    "\n",
    "    yPos += 450\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distribuição bairros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecThree():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        \"DISTRIBUIÇÃO DOS CASOS POR BAIRRO\")\n",
    "    \n",
    "    yPos += 50\n",
    "    xPos = 30\n",
    "    multiplier = 210    # column distance\n",
    "\n",
    "\n",
    "    # Neighboor column names\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.setFont(\"Montserratbi\",10)\n",
    "    page.drawString(xPos, yPos, \"Bairros\")\n",
    "    page.drawCentredString(xPos + 2.7*multiplier, yPos, \"Casos de síndrome respiratória não especificada\")\n",
    "    # page.drawCentredString(xPos + 2*multiplier, yPos, \"Baixa Probabilidade\")\n",
    "    page.drawCentredString(xPos + 1.5*multiplier, yPos, \"Casos confirmados\")\n",
    "\n",
    "    # Drawing neighboorhood in pdf\n",
    "    page.setFont(\"Montserratb\",10)\n",
    "    yPos += 5\n",
    "    for i in d2a_vNeighboorhood:\n",
    "        yPos+= 17  \n",
    "        page.drawString(xPos, yPos, i['Neighboorhood'])\n",
    "        page.drawCentredString(xPos + 2.7*multiplier, yPos, str(i['qtdSuspect']))\n",
    "        #page.drawCentredString(xPos + 2*multiplier, yPos, str(i['qtdAnalis']))\n",
    "        page.drawCentredString(xPos + 1.5*multiplier, yPos, str(i['qtdConf']))\n",
    "\n",
    "    # Drawing total of analysis\n",
    "    yPos += 5\n",
    "    page.drawString(xPos, yPos+17, 'Total')\n",
    "    page.drawCentredString(xPos + 2.7*multiplier, yPos + 17, str(sum(item['qtdSuspect'] for item in d2a_vNeighboorhood)))\n",
    "    #page.drawCentredString(xPos + 2*multiplier, yPos + 17, str(sum(item['qtdAnalis'] for item in d2a_vNeighboorhood)))\n",
    "    page.drawCentredString(xPos + 1.5*multiplier, yPos + 17, str(sum(item['qtdConf'] for item in d2a_vNeighboorhood)))\n",
    "\n",
    "    yPos += 100\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Síndrome Respiratória Não Especificada Por Fator De Risco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecFour():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        'SÍNDROME RESPIRATÓRIA NÃO ESPECIFICADA')\n",
    "    yPos += 30\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        'POR FATOR DE RISCO')\n",
    "    yPos += 30\n",
    "\n",
    "    # Draw graphic disease\n",
    "    _dist = 20\n",
    "    page.drawImage(\n",
    "        graphic_CSdiseases, \n",
    "        _dist, \n",
    "        yPos,\n",
    "        pgDim['w']-2*_dist,\n",
    "        (pgDim['w']-2*_dist)/3\n",
    "    )\n",
    "    yPos += 350"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fator de risco confirmados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecFive():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        'CASOS CONFIRMADOS POR FATOR DE RISCO')\n",
    "    yPos += 30\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        \"(EM PORCENTAGEM)\")\n",
    "    yPos += 30\n",
    "\n",
    "    # Draw graphic disease\n",
    "    _dist = 20\n",
    "    wh_proportion = 1/3 # this proportion is, approximately, the same as figure ploting\n",
    "    page.drawImage(\n",
    "        graphic_Cdiseases, \n",
    "        _dist, \n",
    "        yPos,\n",
    "        pgDim['w']-2*_dist,\n",
    "        (pgDim['w']-2*_dist)/3\n",
    "    )\n",
    "    yPos += 350\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Semana epidemiológica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecSix():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        'SÍNDROME RESPIRATÓRIA NÃO ESPECIFICADA')\n",
    "    yPos += 30\n",
    "    page.drawCentredString(\n",
    "        pgDim['w']/2,\n",
    "        yPos,\n",
    "        'POR SEMANA EPIDEMIOLÓGICA')\n",
    "    yPos += 30\n",
    "    \n",
    "    # Draw graphic disease\n",
    "    _dist = 20\n",
    "    page.drawImage(\n",
    "        graphic_CSweek, \n",
    "        _dist, \n",
    "        yPos,\n",
    "        pgDim['w']-2*_dist,\n",
    "        (pgDim['w']-2*_dist)/3\n",
    "    )\n",
    "    yPos += 350\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Footer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putFooter():\n",
    "    global page\n",
    "    \n",
    "    # page.drawImage(logo, pgDim['w']-200, pgDim['h']-70, 125, 38) # Removed -- elections\n",
    "    \n",
    "    # Set color\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "\n",
    "    # Draw icons\n",
    "    page.setFont(\"FontAwesomeS\",12)\n",
    "    page.drawCentredString(pgDim['w']/2 - 100, pgDim['h']-40,'') # Link\n",
    "    page.setFont(\"FontAwesomeB\",12)\n",
    "    page.drawCentredString(pgDim['w']/2 - 110, pgDim['h']-25,'') # Facebook\n",
    "    \n",
    "    # Draw Text\n",
    "    page.setFont(\"Montserrat\",12)\n",
    "    page.drawCentredString(pgDim['w']/2, pgDim['h']-60, \"Mais informações:\") # xpos = 150\n",
    "    _site = 'novoportal.itabira.mg.gov.br/'\n",
    "    _fb = 'facebook.com/prefeituraitabira'\n",
    "    \n",
    "    space = 100\n",
    "    pdfDrawLink('http://{}'.format(_site), pgDim['w']/2-space, pgDim['h']-50, 2*space, 10)\n",
    "    pdfDrawLink('https://{}'.format(_fb), pgDim['w']/2-space, pgDim['h']-35, 2*space, 10)\n",
    "\n",
    "    page.drawCentredString(pgDim['w']/2, pgDim['h']-40,_site)\n",
    "    page.drawCentredString(pgDim['w']/2, pgDim['h']-25,_fb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save():\n",
    "    global page\n",
    "\n",
    "    page.save()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crescimento síndrome respiratória não especificada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecSeven():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "      pgDim['w']/2,\n",
    "      yPos,\n",
    "      \"CRESCIMENTO DE CASOS DE SÍNDROME RESPIRATÓRIA\")\n",
    "    yPos += 30\n",
    "    page.drawCentredString(\n",
    "      pgDim['w']/2,\n",
    "      yPos,\n",
    "      \"NÃO ESPECIFICADA\")\n",
    "    yPos += 30\n",
    "    # Draw graphic disease\n",
    "    _dist = 20\n",
    "    page.drawImage(\n",
    "      graphic_Stimeline, \n",
    "      _dist, \n",
    "      yPos,\n",
    "      pgDim['w']-2*_dist,\n",
    "      (pgDim['w']-2*_dist)/3\n",
    "    )\n",
    "    yPos += 350\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crescimento de casos confirmados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putSecEight():\n",
    "    global page, yPos\n",
    "\n",
    "    # Titles\n",
    "    page.setFont(\"Montserrat\",24)\n",
    "    page.setFillColor(rlabColors.gray)\n",
    "    page.drawCentredString(\n",
    "      pgDim['w']/2,\n",
    "      yPos,\n",
    "      \"CRESCIMENTO DE CASOS CONFIRMADOS\")\n",
    "    yPos += 30\n",
    "\n",
    "    # Draw graphic disease\n",
    "    _dist = 20\n",
    "    page.drawImage(\n",
    "      graphic_Ctimeline, \n",
    "      _dist, \n",
    "      yPos,\n",
    "      pgDim['w']-2*_dist,\n",
    "      (pgDim['w']-2*_dist)/3\n",
    "    )\n",
    "    yPos += 350\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get internal pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getInternal(fileName):\n",
    "    pdf_Start(fileName)\n",
    "    setTitle('Boletim Interno')\n",
    "    putHeader('HeadOrange','Head2Orange')\n",
    "    putEmphasis()\n",
    "    putSecOne()\n",
    "    putSecTwo()\n",
    "    putSecThree()\n",
    "    putSecFour()\n",
    "    putSecFive()\n",
    "    putSecSix()\n",
    "    putSecSeven()\n",
    "    putSecEight()\n",
    "    putFooter()\n",
    "    save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get external pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getExternal(fileName):\n",
    "    pdf_Start(fileName)\n",
    "    setTitle('Boletim Externo')\n",
    "    putHeader('BlueFB','Head2Blue')\n",
    "    putEmphasis()\n",
    "    putSecTwo()\n",
    "    putFooter()\n",
    "    save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0IKsYdkmyjyl"
   },
   "source": [
    "# External PDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JFAhI2Cfyjyz"
   },
   "outputs": [],
   "source": [
    "fileName = 'pdfs/Boletim-Externo_{}-{}-{}.pdf'.format(DAY,MONTH_NAME,YEAR)\n",
    "pgDim = {'w':792,'h':1150}\n",
    "\n",
    "getExternal(fileName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VpBMmgCzfAnb"
   },
   "source": [
    "# Internal PDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HFFUMbT6ec2H"
   },
   "outputs": [],
   "source": [
    "fileName = 'pdfs/Boletim-Interno_{}-{}-{}.pdf'.format(DAY,MONTH_NAME,YEAR)\n",
    "pgDim = {'w':792,'h':5450}\n",
    "\n",
    "getInternal(fileName)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "CoronaPlotsV2",
   "provenance": [],
   "toc_visible": true
  },
  "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.7"
  },
  "toc-autonumbering": true,
  "toc-showmarkdowntxt": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}