coleta_tratamento_dados.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Open Data Day - 2024\n",
    "## Coleta de dados de recursos (em valores) disponíveis para os Objetivos de Desenvolvimento Sustentável (ODS)\n",
    "\n",
    "Preparação dos dados para consumo no dashboard streamlit\n",
    "\n",
    "### Fonte de dados\n",
    "- url : https://brasil.un.org/pt-br/sdgs\n",
    "\n",
    "### Atualizações\n",
    "- 27/02/2024 : Início do projeto\n",
    "- 28/02/2024 : Formatação do projeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importação das dependências"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from selenium.webdriver import ActionChains, Keys\n",
    "from selenium.webdriver.common.by import By\n",
    "from pathlib import Path\n",
    "\n",
    "from config import Config\n",
    "from open_data_day_2024.web_page import get_element_by_xpath, get_page_driver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Localização do arquivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summary_file = Path.cwd() / \"data\" / \"processed\" / f\"summary_recursos_disponiveis.pkl\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seletores XPATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMBOBOX_ANO_XPATH = ('//h2[contains(text(), \"Onde são investidos os recursos?\")]'\n",
    "                      '//ancestor::div[3]//label[@id=\"Year\"]//following::div[1]')\n",
    "RECURSOS_DISPONIVEIS_XPATH = '//h4[contains(text(),\"Recursos Disponíveis\")]'\n",
    "ITEM_ODS_DIST_RECURSOS_XPATH = '//ul[contains(@class,\"list\")]//strong//parent::div'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### URL da página"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Config.URL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cria uma instância do ChromeWebDriver e abre a página"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver = get_page_driver(Config.URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seleciona o elemento selectbox na DOM e move até a posição dele na página\n",
    "Document Object Model (DOM): No contexto da programação web, DOM refere-se ao Document Object Model, que é uma interface de programação para documentos HTML, XML e SVG. Ele representa a estrutura do documento como uma árvore de objetos, onde cada nó representa parte do documento, como elementos HTML, atributos e texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "ActionChains(driver).move_to_element(selectbox_ano).perform()\n",
    "selectbox_ano.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lista todo os anos encontrados na selectbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "ActionChains(driver).click(selectbox_ano).perform()\n",
    "lista_anos_selectbox = driver.find_elements(By.XPATH, \"//li[contains(text(), '20')]\")\n",
    "ANOS_SELECTBOX = list(set([ano.text for ano in lista_anos_selectbox if ano.text]))\n",
    "lista_anos_selectbox[-1].send_keys(Keys.ESCAPE)\n",
    "print(ANOS_SELECTBOX)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Altera o ano no elemento selectbox e imprime o ano selecionado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "ano = 2024\n",
    "\n",
    "while True:\n",
    "    selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "    ActionChains(driver).move_to_element(selectbox_ano).perform()\n",
    "    if selectbox_ano.text == str(ano):\n",
    "        break\n",
    "    ActionChains(driver).click(selectbox_ano).perform()\n",
    "    \n",
    "    item_to_select = get_element_by_xpath(driver, f\"//li[contains(text(), {ano})]\")\n",
    "    ActionChains(driver).click(item_to_select).perform()\n",
    "    \n",
    "    selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "    try:                \n",
    "        if selectbox_ano.text == str(ano):\n",
    "            break   \n",
    "    except AttributeError:\n",
    "        if item_to_select is not None:\n",
    "            item_to_select.send_keys(Keys.ESCAPE)\n",
    "    \n",
    "selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "ActionChains(driver).move_to_element(selectbox_ano).perform()\n",
    "selectbox_ano.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seleciona o elemento \"recursos diponíveis\" e exibe o seu conteúdo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recursos_disponiveis = get_element_by_xpath(driver, RECURSOS_DISPONIVEIS_XPATH)\n",
    "recursos_disponiveis.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seleciona a lista de itens do OSD com suas respectivas informações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "item_ods_recurso_list = driver.find_elements(By.XPATH, ITEM_ODS_DIST_RECURSOS_XPATH)\n",
    "distribuicao_recursos = list()\n",
    "for item in item_ods_recurso_list:\n",
    "    titulo, percentual = item.text.splitlines()\n",
    "    percentual = float(percentual.split('%')[0].replace(',', '.'))\n",
    "    distribuicao_recursos.append([titulo, percentual])\n",
    "    print(f'{titulo:.<50}', percentual)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fecha o navegador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "driver.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coleta e Manipulação de dados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função que centraliza todas as ações realizadas acima\n",
    "def get_dados_ods(ano: int):\n",
    "    \"\"\"Recupera os dados de recursos disponíveis para Os ODS com base no ano\n",
    "\n",
    "    Args:\n",
    "        ano (int): ano dos recursos disponíveis\n",
    "\n",
    "    Returns:\n",
    "        Dict[str, Any]: retorna os dados raspados inclusos em um dicionário\n",
    "    \"\"\"\n",
    "    \n",
    "    driver = get_page_driver(Config.URL)\n",
    "\n",
    "    # seleciona o ano na selectbox\n",
    "    while True:\n",
    "        selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "        ActionChains(driver).move_to_element(selectbox_ano).perform()\n",
    "        if selectbox_ano.text == str(ano):\n",
    "            break\n",
    "        ActionChains(driver).click(selectbox_ano).perform()\n",
    "        \n",
    "        item_to_select = get_element_by_xpath(driver, f\"//li[contains(text(), {ano})]\")\n",
    "        ActionChains(driver).click(item_to_select).perform()\n",
    "        \n",
    "        selectbox_ano = get_element_by_xpath(driver, COMBOBOX_ANO_XPATH)\n",
    "        try:                \n",
    "            if selectbox_ano.text == str(ano):\n",
    "                break   \n",
    "        except AttributeError:\n",
    "            if item_to_select is not None:\n",
    "                item_to_select.send_keys(Keys.ESCAPE)\n",
    "\n",
    "    # recupera as informacoes dos elementos selecionados\n",
    "    recursos_disponiveis = get_element_by_xpath(driver, RECURSOS_DISPONIVEIS_XPATH)\n",
    "    recursos_disponiveis = recursos_disponiveis.text\n",
    "    recursos_valores, recurso_notacao = recursos_disponiveis.split('$')[-1].split()\n",
    "    recursos_valores = recursos_valores.replace(',', '.')\n",
    "\n",
    "    # converte o valor abreviado conforme a notacao utilizada\n",
    "    if 'billion' in recurso_notacao:\n",
    "        recursos_valores = float(recursos_valores) * 1_000_000_000\n",
    "    elif 'million' in recurso_notacao:\n",
    "        recursos_valores = float(recursos_valores) * 1_000_000\n",
    "    elif 'thousand' in recurso_notacao:\n",
    "        recursos_valores = float(recursos_valores) * 1_000\n",
    "\n",
    "    # cria um dicionario para mapear os dados obtidos\n",
    "    dados_dist_recursos = {\n",
    "        'ano': ano,\n",
    "        'recursos_disponiveis': recursos_disponiveis,\n",
    "        'recursos_valores': recursos_valores,\n",
    "    }\n",
    "\n",
    "    # adiciona os valores da distriuicao dos recurso ao dicionario\n",
    "    if recursos_disponiveis is not None:\n",
    "        item_ods_recurso_list = driver.find_elements(By.XPATH, ITEM_ODS_DIST_RECURSOS_XPATH)\n",
    "        distribuicao_recursos = list()        \n",
    "        for item in item_ods_recurso_list:\n",
    "            titulo, percentual = item.text.splitlines()\n",
    "            percentual = float(percentual.split('%')[0].replace(',', '.'))\n",
    "            distribuicao_recursos.append([titulo, percentual])\n",
    "        dados_dist_recursos.update({'distribuicao_recursos': distribuicao_recursos})\n",
    "\n",
    "    return dados_dist_recursos\n",
    "\n",
    "get_dados_ods(2024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converte os dados em DataFrames pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dict = {}\n",
    "for ano in sorted(ANOS_SELECTBOX):\n",
    "    print(ano)\n",
    "\n",
    "    # busca os dados dos anos existentes na selectbox dos recursos disponíveis\n",
    "    dados = get_dados_ods(ano)\n",
    "    \n",
    "    # converte em DataFrames os dados coletados\n",
    "    df = pd.DataFrame(dados['distribuicao_recursos'], columns=['Objetivo', 'Percentual'])\n",
    "    df['Ano'] = dados['ano']\n",
    "    df['Valor'] = df['Percentual']\n",
    "    df['Valor'] = df['Valor'].apply(lambda x: (x / 100) * dados['recursos_valores'])\n",
    "\n",
    "    # adiciona os DataFrames e seus respectivos dados no dicionário\n",
    "    df_dict[ano] = (dados, df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Itera sobre o dicionário e exibe o conteúdo dos Dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ano, registro in df_dict.items():\n",
    "    dados, df = registro\n",
    "    print(ano, '-', dados['recursos_disponiveis'])\n",
    "    display(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatena todos os dataframes em apenas um"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([v[1] for k, v in df_dict.items()], ignore_index=True)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Salve o arquivo de saida dentro do diretório processed\n",
    "\n",
    "Salve o arquivo no diretório processed que esta propriamente limpo. Ele será lido e usado mais tarde para outras análises.\n",
    "Outras opções além do pickle incluem:\n",
    "- feather: é um formato de arquivo binário para armazenamento eficiente de dados em data frames. É projetado para   interoperabilidade entre linguagens de programação, sendo especialmente eficaz para dados tabulares. Feather é rápido para leitura e gravação, e é compatível com R e Python, tornando-o útil para transferir dados entre essas duas \n",
    "\n",
    "- msgpack: é um formato de serialização de dados binários que é mais eficiente em termos de espaço e tempo de processamento do que o formato JSON. Ele é projetado para ser rápido e eficiente em termos de espaço de armazenamento, e pode ser utilizado para serializar uma ampla variedade de tipos de dados, tornando-o útil para comunicação de dados entre sistemas distribuídos.\n",
    "\n",
    "- parquet: é um formato de arquivo colunar projetado para armazenar dados tabulares de forma eficiente em termos de espaço e tempo de acesso. Ele é especialmente útil para armazenar e analisar grandes conjuntos de dados, pois permite a leitura eficiente de subconjuntos de colunas, o que pode acelerar a análise de consultas. Parquet é comumente usado em ambientes de big data, como Hadoop e Apache Spark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_pickle(summary_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "open-data-day-2024-gn3maNcN-py3.11",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}