nbk_eval_program_backup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4b48e5c3",
   "metadata": {},
   "source": [
    "## <center>Avaliação de propostas e produções em pesquisa<br /> Programa de Incentivo à Pesquisa (PIP) 2024 da Fiocruz Ceará</center>\n",
    "\n",
    "    Roberto Nicolete – Fiocruz Ceará\n",
    "    Marcos Aires – Fiocruz Ceará\n",
    "\n",
    "**Objetivo:**\n",
    "\n",
    "    Avaliar indicadores em pesquisa para ranquear propostas de pesquisa com base em dados dos currículos de proponentes às bolsas em pesquisa. São considerados os currículos dos orientadores que submeteram inscrições ao Programa de Incentivo à Pesquisa (PIP) em sua edição no ano de 2024, contemplando produções no período de 2020 a 2024, com base nos mesmos parâmetros definidos no edital Fiocruz Ceará Nº 01/2024"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3beb4392",
   "metadata": {},
   "source": [
    "**Contexto e Motivação** \n",
    "\n",
    "Partimos da necessidade de avaliar objetivamente o potencial de impacto, condicionado à cientificidade de propostas de pesquisa. Especialmente no contexto de polarização inerente às sociedades modernas, onde ideologias e preconceitos podem influenciar o processo de construção do conhecimento, o objetivo principal traçado para realizar avaliações objetivas de propostas de pesquisa foi criar uma ferramenta que pudesse identificar falhas e incoerências na estrutura causal das propostas, promovendo o rigor científico e a busca pela verdade, sem gerar atritos desnecessários. \n",
    "\n",
    "Portanto, descreve-se a seguir, em resumo, as bases para implementar o Modelo Computacional para avaliar propostas de pesquisa, quanto às suas cientificidade e potencial de impacto em termos de inovação tecnológica."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c3cf167",
   "metadata": {},
   "source": [
    "# <b>F00: Preparar Ambiente local</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9700467c",
   "metadata": {},
   "source": [
    "### Instalações"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aed4cec7",
   "metadata": {},
   "source": [
    "#### Git, WSL, Contêiner Docker, ambiente virtual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dc48fc7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Instalar o WSL e integrar ao VSCode, no terminal rodar:\n",
    "## Verificar versões já instaladas\n",
    "#wsl -l -v\n",
    "## Atualizar para WSL2 para que as instalações de distros já rodem em WSL2 por padrão\n",
    "#wsl --set-default-version 2\n",
    "## Reiniciar a máquina e instalar distribuição Linux Ubuntu LTS pelo store do windows\n",
    "## Configurar VScode: iniciar VScode e instalar a extensão \"Remote - WSL\" para desenvolver diretamente no VSCode dentro do ambiente do WSL.\n",
    "# Após a instalação, na parte inferior esquerda da janela do VSCode, aparecerá o ícone verde.\n",
    "# Clicar no ícone verde e selecionar \"New WSL Window\" ou \"Reopen in WSL\" se o projeto já estiver aberto.\n",
    "# Agora, o VSCode estará rodando dentro do contexto do seu WSL, pode-se abrir terminais dentro do VSCode que acessarão diretamente o Linux.\n",
    "\n",
    "## Instalar Python e o Pip:\n",
    "# sudo apt update\n",
    "# sudo apt install python3-pip\n",
    "\n",
    "## Inserir dados do Git no VScode, no terminal rodar:\n",
    "# git config --global user.name \"nome_usuario_gi\"\n",
    "# git config --global user.email \"email_git\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f72ab53",
   "metadata": {},
   "source": [
    "#### Instalar os gerenciador e pacotes pip e Conda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3348635c",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Intalar os gerenciador de pacotes PIP  no terminal do WSL executar:\n",
    "# sudo apt update\n",
    "# sudo apt upgrade\n",
    "# sudo apt install python3-pip\n",
    "# python3 -m pip install --upgrade pip\n",
    "\n",
    "## Atualizar o gerenciador de pacotes e ferramentas de compilação\n",
    "# %pip install --upgrade pip setuptools wheel\n",
    "\n",
    "## Instalar primeiro o GraphViz antes do ygraphviz, no terminal do WSL rodar e depois reiniciar o kernel:\n",
    "## Para Linux e WSL instalar a partir do terminal:\n",
    "# sudo apt-get install graphviz graphviz-dev\n",
    "\n",
    "## Para Windows, atualizar o gerenciador de pacotes e ferramentas de compilação:\n",
    "# %pip install --upgrade pip setuptools wheel\n",
    "\n",
    "## Instalar o Chocolatey (Só para Windows, não no WSL)\n",
    "## Baixar e instalar o gerenciador chocolatey em https://jcutrer.com/windows/install-chocolatey-choco-windows10\n",
    "# Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))\n",
    "\n",
    "## Baixar e instalar o Graphviz em https://www.graphviz.org/download/\n",
    "## https://savleen307.medium.com/pygraphviz-installation-in-windows-f45cc6fed981\n",
    "## Seguir as instruções em https://pygraphviz.github.io/documentation/stable/install.html#id1\n",
    "# O comando na página acima está errado por conter duas aspas onde não deve, executar o comando abaixo:\n",
    "# python -m pip install --use-pep517 --config-settings=\"--global-option=build_ext\" --config-settings=\"--global-option=-IC:\\Program Files\\Graphviz\\include\" --config-settings=--global-option=\"-LC:\\Program Files\\Graphviz\\lib\" pygraphviz\n",
    "\n",
    "## Instalar o pacote no ambiente local\n",
    "# %pip install pygraphviz\n",
    "\n",
    "## Para instalar o Conda (Miniconda ou Anaconda) no WSL, baixar o script de instalação diretamente do site oficial e executá-lo manualmente.\n",
    "## Passos para instalar o Miniconda como exemplo:\n",
    "## Baixar script de instalação do Miniconda para Linux:\n",
    "# wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
    "# bash Miniconda3-latest-Linux-x86_64.sh\n",
    "# conda --version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0af3065f",
   "metadata": {},
   "source": [
    "#### Instalar requirements.txt e importar bibliotecas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a25a9ffe",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Localizar requirements.txt para instalar bibliotecas no ambente\n",
    "# os.listdir('./../../../../')\n",
    "# %pip install -r ./../../../../requirements.txt\n",
    "\n",
    "## Outras instalações pontuais quando necessário, por exemplo:\n",
    "# import os, tqdm\n",
    "# %pip install chardet\n",
    "# print(tqdm.__version__)\n",
    "# %pip3 install --upgrade plotly\n",
    "# %pip3 install omegaconf --upgrade"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c87ef1b",
   "metadata": {},
   "source": [
    "#### Instalar e configurar GPU e drivers CUDA Toolkit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d2bc898b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Instalar drivers da GPU e compilador CUDA Nvidia\n",
    "## Obter comandos adequados para cada sistema em: https://developer.nvidia.com/cuda-downloads\n",
    "## Exemplo para Linux com Ubuntu\n",
    "# wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin\n",
    "# sudo mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600\n",
    "# wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda-repo-wsl-ubuntu-12-4-local_12.4.0-1_amd64.deb\n",
    "# sudo dpkg -i cuda-repo-wsl-ubuntu-12-4-local_12.4.0-1_amd64.deb\n",
    "# sudo cp /var/cuda-repo-wsl-ubuntu-12-4-local/cuda-*-keyring.gpg /usr/share/keyrings/\n",
    "# sudo apt-get update\n",
    "# sudo apt-get -y install cuda-toolkit-12-4\n",
    "\n",
    "## Instruções para instalação do PyTorch para usar a GPU em Windows\n",
    "# https://sh-tsang.medium.com/tutorial-cuda-cudnn-anaconda-jupyter-pytorch-installation-in-windows-10-96b2a2f0ac57\n",
    "\n",
    "## Para máquinas com apenas CPU\n",
    "# !pip install torch torchvision\n",
    "\n",
    "## Testar cálculo na GPU\n",
    "# import torch\n",
    "# x = torch.rand(5, 3)\n",
    "# print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e551ffdc",
   "metadata": {},
   "source": [
    "#### Implementar classes para obter e preparar dados"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c921ae65",
   "metadata": {},
   "source": [
    "    LattesScraper (Extrair currículos Lattes)\n",
    "    SoupParser (Extrair dados de Objeto Soup)\n",
    "    Neo4jPersister (Persistir em Neo4j)\n",
    "    DatasetArticlesGenerator (Gerar Datasets)\n",
    "    DictToHDF5 (converter dicionários para HDF5)\n",
    "    ArticlesCounter (Montar qte artigos e atualização)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8cb1692",
   "metadata": {},
   "source": [
    "# <b>F01: Obter dados das Produções</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dd18ddb",
   "metadata": {},
   "source": [
    "## Rodar testes e definir pastas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f6e3cb",
   "metadata": {},
   "source": [
    "### Gerar pastas e classes de processamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "edfd06ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from getpass import getpass\n",
    "from datetime import datetime\n",
    "from IPython.display import clear_output\n",
    "import pandas as pd, os, re, sys, time, json, subprocess\n",
    "\n",
    "## Configurar exibição do pandas para melhor visualizar os dados\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "pd.set_option('colheader_justify', 'left')\n",
    "pd.set_option('display.max_rows', 600)\n",
    "\n",
    "def find_repo_root(path='.', depth=10):\n",
    "    ''' \n",
    "    Busca o arquivo .git e retorna string com a pasta raiz do repositório\n",
    "    '''\n",
    "    # Limitar profundidade para evitar loop infinito\n",
    "    if depth < 0:\n",
    "        return None\n",
    "    path = Path(path).absolute()\n",
    "    if (path / '.git').is_dir():\n",
    "        return path\n",
    "    return find_repo_root(path.parent, depth-1)\n",
    "\n",
    "## Definir a pasta de base do repositório local\n",
    "base_repo_dir = find_repo_root()\n",
    "\n",
    "## Sempre construir os caminhos usando os.path.join para compatibilidade WxL\n",
    "folder_utils = os.path.join(base_repo_dir, 'utils')\n",
    "folder_domain = os.path.join(base_repo_dir, 'source', 'domain')\n",
    "folder_data_input = os.path.join(base_repo_dir, '_data', 'in_csv')\n",
    "folder_data_output = os.path.join(base_repo_dir, '_data', 'out_json')\n",
    "\n",
    "## Adicionar pastas locais ao sys.path para importar pacotes criados localmente\n",
    "sys.path.append(folder_utils)\n",
    "sys.path.append(folder_domain)\n",
    "from environment_setup import EnvironmentSetup\n",
    "from chromedriver_manager import ChromeDriverManager\n",
    "from neo4j_persister import Neo4jPersister\n",
    "from lattes_scrapper import JSONFileManager, LattesScraper, HTMLParser, SoupParser, GetQualis, ArticlesCounter, DictToHDF5, attribute_to_be_non_empty\n",
    "\n",
    "# from scraper_pasteur import PasteurScraper\n",
    "# from scraper_sucupira import SucupiraScraper\n",
    "# from scraper_sucupira_edge import SucupiraScraperEdge\n",
    "\n",
    "t00 = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff45fefc",
   "metadata": {},
   "source": [
    "### Checar Chromedriver e GoogleChrome"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71efa162",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criar instância da classe ChromeDriverManager e verificar compatibilidade nas versões do Chrome e Chromedriver\n",
    "actualizer = ChromeDriverManager()\n",
    "actualizer.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3962aad",
   "metadata": {},
   "source": [
    "### Obter Qualis Periódicos Plataforma Sucupira"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d03c0036",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sucupira = SucupiraScraperEdge()\n",
    "# sucupira.scrape_sucupira()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7b06c3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criar instância da classe EnvironmenSetup e preparar pastas\n",
    "preparer = EnvironmentSetup()\n",
    "preparer.set_root_path(base_repo_dir)\n",
    "# folder_name = input(\"Digite o nome da pasta principal: \")\n",
    "# preparer.set_root_path(folder_name)\n",
    "preparer.try_cpu()\n",
    "preparer.try_gpu()\n",
    "preparer.try_amb()\n",
    "# preparer.try_browser()\n",
    "preparer.preparar_pastas()\n",
    "\n",
    "## Para remover diretórios no terminal linux\n",
    "# !rm -rf /home/mak/fioce\n",
    "# os.listdir('/home/mak/fioce')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616b92e7",
   "metadata": {},
   "source": [
    "## Montar lista de nomes dos Docentes (lista_busca)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55130d7a",
   "metadata": {},
   "source": [
    "### Carregar nomes da planilha de Docentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "279f1c2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ler dados do arquivo Excel do Setor de Recursos Humanos\n",
    "pathdata = '_data/in_xls/'\n",
    "datasheet = 'fioce_colaboradores-2023.xls'\n",
    "\n",
    "# Ler apenas os cabeçalhos do arquivo Excel\n",
    "headers = pd.read_excel(pathdata+datasheet, skiprows=3, header=0, nrows=0).columns\n",
    "# headers\n",
    "\n",
    "# Usar função para indicar quais colunas devem ser eliminadas na leitura\n",
    "def cols_to_keep(col_name):\n",
    "    return col_name not in ['QUANT','Unnamed: 3','Unnamed: 6','Unnamed: 9','ADICIONAL OCUPACIONAL',\n",
    "                            'EMPRESA/BOLSA/PROGRAMA','GESTOR','ADI','POSSE NA FIOCRUZ',\n",
    "                            'VIGÊNCIA BOLSA/ENCERRAMENTO DO CONTRATO','Unnamed: 17',\n",
    "                            'EMAIL INSTITUCIONAL','EMAIL PESSOAL','GENERO','DATA NASCIMENTO',\n",
    "                            'Unnamed: 22','FORMAÇÃO','ENDEREÇO RESIDENCIAL']\n",
    "\n",
    "# Filtrar cabeçalhos com base na função\n",
    "selected_columns = [col for col in headers if cols_to_keep(col)]\n",
    "\n",
    "# Ler dados do arquivo Excel do Setor de Recursos Humanos\n",
    "fioce_pessoal = pd.read_excel(pathdata+datasheet, skiprows=3, header=0, usecols=selected_columns)\n",
    "print(f'{len(fioce_pessoal.index)} nomes de colaboradores no total, todos vínculos e status')\n",
    "print(f'{len(fioce_pessoal[\"VÍNCULO\"].unique()):3} tipos de vínculos')\n",
    "\n",
    "print('\\nTipos de vínculos',list(fioce_pessoal['VÍNCULO'].unique()))\n",
    "print('  Tipos de status',list(fioce_pessoal['STATUS'].unique()))\n",
    "filtro1 = fioce_pessoal.VÍNCULO == 'SERVIDOR'\n",
    "filtro2 = fioce_pessoal['STATUS'].isin(['ATIVO', 'AFASTADO'])\n",
    "lista_nomes = fioce_pessoal[(filtro1) & (filtro2)]['NOME'].tolist()\n",
    "\n",
    "print(f'\\n{len(lista_nomes)} nomes para extrair currículos')\n",
    "for i,nome in enumerate(lista_nomes):\n",
    "    print(f'{i+1:2}. {nome}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bc89b867",
   "metadata": {},
   "outputs": [],
   "source": [
    "grupos_internos = fioce_pessoal['ÁREA'].unique()\n",
    "coordenacoes=[]\n",
    "grupos_tematicos=[]\n",
    "for i in grupos_internos:\n",
    "    # print(i)\n",
    "    if 'coordenação' in str(i).lower():\n",
    "        coordenacoes.append(i)\n",
    "    elif str(i) != 'nan':\n",
    "        grupos_tematicos.append(str(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "288fb373",
   "metadata": {},
   "outputs": [],
   "source": [
    "coordenacoes.sort()\n",
    "coordenacoes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7507b77",
   "metadata": {},
   "outputs": [],
   "source": [
    "grupos_tematicos.sort()\n",
    "grupos_tematicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5adb022c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Outras atividades não relacionadas diretamente com pesquisa\n",
    "remover = ['Angela Christina De Moraes Ostritz',\n",
    "           'Bruno Bezerra Carvalho',\n",
    "           'Carlos Jose Araujo Pinheiro',\n",
    "           'Charles Cerqueira De Abreu',\n",
    "           'Ezequiel Valentim De Melo',\n",
    "           'Ivanildo Lopes Farias',\n",
    "           'João Baptista Estabile Neto',\n",
    "           'Kamila Matos Albuquerque',\n",
    "           'Luciana Coelho Serafim',\n",
    "           'Luciano Pinto Zorzanelli',\n",
    "           'Luciana Silvério Alleluia Higino Da Silva',\n",
    "           'Luis Fernando Pessoa De Andrade',\n",
    "           'Marcelo Jorge Lopes Coutinho',\n",
    "           'Nilton Luiz Costa Machado',\n",
    "           'Patricia Maria Ferreira da Silva',\n",
    "           'Renato Caldeira De Souza',\n",
    "           'Sergio Dos Santos Reis',\n",
    "           'Clarice Gomes E Souza Dabés',\n",
    "           'Luciana Pereira Lindenmeyer',\n",
    "           'Rodrigo Carvalho Nogueira',\n",
    "           \n",
    "        #    'Ana Camila Oliveira Alves',\n",
    "        #    'Antonio Marcos Aires Barbosa',\n",
    "        #    'Venúcia Bruna Magalhães Pereira',\n",
    "           ]\n",
    "\n",
    "trocar = {\n",
    "    'Maximiliano Loiola Ponte De Souza': 'Maximiliano Ponte',\n",
    "    'Raphael Trevizani Roque': 'Raphael Trevizani',\n",
    "    }\n",
    "\n",
    "# Adicionar pós-doc e demais alunos ou orientandos membros de equipes de projetos\n",
    "# adicionar = [\n",
    "#     'Ana Carolina Matias Dinelly Pinto',\n",
    "#     'Geraldo Rodrigues Sartori',\n",
    "#     'Elaine Silva Nascimento Andrade',\n",
    "#     'Cecili Barrozo Mendes',\n",
    "#     'Christiane França Martins',\n",
    "#     'Ketlen Christine Ohse',\n",
    "#     'Clarissa Perdigao Mello Ferraz',\n",
    "#     'Allysson Allan de Farias',\n",
    "#     'Júlio César Martins Ximenes',\n",
    "#     'Wallady da Silva Barroso',\n",
    "#     'Lucas Lima de Carvalho',\n",
    "#     'Manuel Alves dos Santos Júnior',\n",
    "#     'Valdir Ferreira de Paula Junior',\n",
    "#     'Felipe Augusto Rocha Rodrigues',\n",
    "#     'Talita Abrante Leite',\n",
    "#     'Fátima de Cássia Evangelista de Oliveira',\n",
    "#     'Hélcio Silva dos Santos',\n",
    "#     'Rodolfo de Melo Nunes',\n",
    "#     'Ana Karine Rocha de Melo Leite',\n",
    "#     'Conceição da Silva Martins Rebouças',\n",
    "#     'Maria Francilene Souza Silva',\n",
    "#     'Anita Oliveira Brito Pereira Bezerra Martins',\n",
    "#     'Isaac Moura Araújo',\n",
    "#     'Débora Gaspar'   \n",
    "# ]\n",
    "\n",
    "lista_busca=[]\n",
    "for i in lista_nomes:\n",
    "    if i.strip() in trocar.keys():\n",
    "        lista_busca.append(trocar.get(i))\n",
    "    elif i.strip() not in remover:\n",
    "        lista_busca.append(i)\n",
    "# for i in adicionar:\n",
    "#     if i.strip().lower() in [x.strip().lower() for x in lista_nomes]:\n",
    "#         pass\n",
    "#     elif i.strip() not in remover:\n",
    "#         lista_busca.append(i.strip().title())\n",
    "\n",
    "# Limitando quantidade para testes\n",
    "# lista_busca = lista_busca[:5]\n",
    "\n",
    "print(f'{len(lista_busca)} currículos a extrair da plataforma Lattes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "210bcc95",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extração reduzida para testes\n",
    "# lista_busca = lista_busca[32:34]\n",
    "# lista_busca"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d842eb06",
   "metadata": {},
   "source": [
    "### Carregar nomes de arquivo .csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "580d2799",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os, pandas as pd\n",
    "# from environment_setup import EnvironmentSetup\n",
    "# preparer = EnvironmentSetup()\n",
    "\n",
    "# ## Montar lista_nomes com arquivo .csv\n",
    "# pathfilename = os.path.join(folder_data_input,'nomesdocentes.csv')\n",
    "# lista_busca = pd.read_csv(pathfilename,header=None)[0].values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35849f4e",
   "metadata": {},
   "source": [
    "## <b>F01a: Extrair dados dos Docentes</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d9f8b44",
   "metadata": {},
   "source": [
    "### Definir termos de vínculo para buscas por nomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95ffba79",
   "metadata": {},
   "outputs": [],
   "source": [
    "repo_root = preparer.find_repo_root(os.getcwd())\n",
    "pasta_dados = os.path.join(repo_root,'data','output')\n",
    "termos_busca = ['Fiocruz', 'Oswaldo Cruz', 'Imunopatologia', 'Ministerio da Saude', 'RENORBIO', 'Biotecnologia', 'Saúde']\n",
    "print(f'{len(lista_busca)} currículos Lattes a extrair')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e2d2a31",
   "metadata": {},
   "source": [
    "### Extrair currículos Docentes da plataforma Lattes\n",
    "     Tempo: 0.4min/currículo em extração serial, paralelizada ??\n",
    "    Espaço: 0,11MB por currículo, 108Gb/milhão de currículos (em JSON)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07a2e8cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Passar parâmetro only_doctors para False para extrair também níveis mestrado e graduação\n",
    "t1 = time.time()\n",
    "scraper = LattesScraper(termos_busca, 'bolt://localhost:7687', 'neo4j', 'password', only_doctors=False)\n",
    "lista_busca = [scraper.normalizar_nome(x) for x in lista_busca]\n",
    "dict_list_docents = scraper.scrape(lista_busca, termos_busca)\n",
    "print(f'\\n{scraper.tempo(t1,time.time())} para busca de {len(lista_busca)} nomes com extração de dados de {len(dict_list_docents)} dicionários')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "340ce781",
   "metadata": {},
   "source": [
    "## Identificar currículos remanescentes ou novos termos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed4d5ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# termos_busca = ['Fiocruz', 'Fundação Oswaldo Cruz', 'Biotecnologia', 'RENORBIO', 'saúde']\n",
    "# scraper = LattesScraper(termos_busca, 'bolt://localhost:7687', 'neo4j', 'password', only_doctors=False)\n",
    "\n",
    "lista_restante = scraper.avaliar_remanescentes(lista_busca, dict_list_docents)\n",
    "lista_restante"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "403fa830",
   "metadata": {},
   "source": [
    "## Completar remanescentes ou adicionar currículos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26715ff5",
   "metadata": {},
   "source": [
    "### Buscar em dados prévios (Em caso de indisponibilidade do site do Lattes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b0d173d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# jfm = JSONFileManager()\n",
    "# filename = 'docents_dict_list_old.json'\n",
    "# dict_list_docents_old, formatted_creation_date, formatted_modification_date, time_count, unit = jfm.load_from_json(os.path.join(folder_data_input,filename))\n",
    "# for n,i in enumerate(dict_list_docents_old):\n",
    "#     nome_old = scraper.normalizar_nome(i.get('Identificação')['Nome'])\n",
    "#     print(f'{n+1:02}. {nome_old}')\n",
    "\n",
    "# lst_extraidos = [scraper.normalizar_nome(x.get('Identificação')['Nome']) for x in dict_list_docents]\n",
    "# for i in dict_list_docents_old:\n",
    "#     nome_old = scraper.normalizar_nome(i.get('Identificação')['Nome'])\n",
    "#     if nome_old not in lst_extraidos and nome_old in [scraper.normalizar_nome(x) for x in lista_busca]:\n",
    "#         print(f\"  Recuperado: {nome_old}\")        \n",
    "#         dict_list_docents.append(i)\n",
    "\n",
    "# print(f\"\\n{len(dict_list_docents)} currículos carregados na lista de dicionários\")\n",
    "# termos_busca = ['Fiocruz', 'Fundação Oswaldo Cruz', 'Biotecnologia', 'RENORBIO', 'saúde']\n",
    "# scraper = LattesScraper(termos_busca, 'bolt://localhost:7687', 'neo4j', 'password', only_doctors=False)\n",
    "# lista_restante = scraper.avaliar_remanescentes(lista_busca, dict_list_docents)\n",
    "# print(f'\\nBusca por {len(lista_busca)} nomes com extração de dados de {len(dict_list_docents)} dicionários')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20e08b2e",
   "metadata": {},
   "source": [
    "### Adicionar novos nomes de currículos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11ae091a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ciipf = ['Caroline Pereira Bittencourt Passaes',\n",
    "# 'Ana Carolina Matias Dinelly Pinto',\n",
    "# 'Clarissa Perdigao Mello Ferraz',\n",
    "# 'Júlio César Martins Ximenes']\n",
    "\n",
    "# for i in ciipf:\n",
    "#     if i not in lista_restante:\n",
    "#         lista_restante.append(i)\n",
    "# for j in lista_restante:\n",
    "#     print(f'   {j}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c9a09b",
   "metadata": {},
   "source": [
    "### Adicionar termos de caracterização de busca dos currículos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "df89d69e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# termos_busca.append('Ceará')\n",
    "# termos_busca.append('Farmacêuticas')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88de2071",
   "metadata": {},
   "source": [
    "### Ajustar formas de nomes distintos da lista inicial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a7cd438",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lista_restante.remove('clarissa perdigao melo')\n",
    "# lista_restante.remove('christiane franca martins teodoro')\n",
    "# lista_restante.remove('elaine silva nascimento')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2069036b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lista_restante.append('clarissa perdigao mello ferraz')\n",
    "# lista_restante.append('christiane franca martins')\n",
    "# lista_restante.append('elaine silva nascimento andrade')\n",
    "lista_restante"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d43ba36",
   "metadata": {},
   "source": [
    "## Extrair currículos remanescentes ou adicionais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b33d6df",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_dict_combinado = scraper.extract_remanescents(lista_restante, dict_list_docents, termos_busca)\n",
    "filepath = os.path.join(folder_data_input,'dict_list_docents.json')\n",
    "print(f'{len(lista_dict_combinado)} currículos extraídos')\n",
    "print('\\n\\nExemplo de dados dos artigos:')\n",
    "[x.get('Produções') for x in lista_dict_combinado][0].get('Artigos completos publicados em periódicos')[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d27f8ff",
   "metadata": {},
   "source": [
    "## Adicionar Qualis e Salvar dados de currículos de Docentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4ab5b5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from lattes_scrapper import GetQualis\n",
    "from pprint import pprint\n",
    "stratifier = GetQualis()\n",
    "\n",
    "t2 = time.time()\n",
    "\n",
    "try:\n",
    "    # Acrescentar Qualis periódicos aos dicionários de docentes quando há remanescentes\n",
    "    pathfilename = os.path.join(folder_data_input,'docents_dict_list.json')\n",
    "    stratifier.buscar_qualis_e_atualizar_arquivo(lista_dict_combinado, pathfilename)\n",
    "    scraper.save_to_json(lista_dict_combinado, pathfilename)\n",
    "    print(f\"Extração salva em: {pathfilename}\")\n",
    "    print(f'{len(lista_dict_combinado)} dicionários com currículos completos extraídos')\n",
    "except:\n",
    "    # Acrescentar Qualis periódicos aos dicionários de docentes\n",
    "    pathfilename = os.path.join(folder_data_input,'docents_dict_list.json')\n",
    "    stratifier.buscar_qualis_e_atualizar_arquivo(dict_list_docents, pathfilename)\n",
    "    scraper.save_to_json(dict_list_docents, pathfilename)\n",
    "    print(f\"Extração salva em: {pathfilename}\")\n",
    "    print(f'{len(dict_list_docents)} dicionários com currículos completos extraídos')\n",
    "\n",
    "print(f'\\n{scraper.tempo(t2,time.time())} para arualização do estrato Qualis para {len(dict_list_docents)} currículos')\n",
    "\n",
    "print('\\n\\nExemplo de dados dos artigos incluindo dado do Qualis:')\n",
    "pprint([x.get('Produções') for x in dict_list_docents][0].get('Artigos completos publicados em periódicos')[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64b193bf",
   "metadata": {},
   "source": [
    "# <b>F01b: Ler dados salvos</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09f6deba",
   "metadata": {},
   "source": [
    "### Listar arquivos JSON gerados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f098cdc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "folder_data_input = os.path.join(os.getcwd(),'_data','in_csv')\n",
    "os.listdir(folder_data_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aef0a65d",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_data_output = os.path.join(os.getcwd(),'_data','out_json')\n",
    "os.listdir(folder_data_output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d344f2",
   "metadata": {},
   "source": [
    "### Remover arquivos desnecessários"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba04d9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "arquivos_para_excluir = ['temp_dict_list.json', 'dict_list_temp.json', 'docents_dict_list_old.json', 'docents_dict_list_old2.json']\n",
    "for arquivo in arquivos_para_excluir:\n",
    "    pathfilename = os.path.join(os.getcwd(),'_data','in_csv',arquivo)\n",
    "    try:\n",
    "        os.remove(pathfilename)\n",
    "        print(f\"Arquivo '{arquivo}' excluído com sucesso!\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Arquivo '{arquivo}' não encontrado.\")\n",
    "    except PermissionError:\n",
    "        print(f\"Erro de permissão ao tentar excluir o arquivo '{arquivo}'.\")\n",
    "    except Exception as e:\n",
    "        print(f\"Ocorreu um erro ao tentar excluir o arquivo '{arquivo}': {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a026ea13",
   "metadata": {},
   "source": [
    "### Carregar e visualizar nomes extraídos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a00a8642",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from getpass import getpass\n",
    "from datetime import datetime\n",
    "from IPython.display import clear_output\n",
    "import pandas as pd, os, re, sys, time, pytz, json, subprocess\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "pd.set_option('colheader_justify', 'left')\n",
    "pd.set_option('display.max_rows', 600)\n",
    "\n",
    "def find_repo_root(path='.', depth=10):\n",
    "    ''' \n",
    "    Busca o arquivo .git e retorna string com a pasta raiz do repositório\n",
    "    '''\n",
    "    # Limitar profundidade para evitar loop infinito\n",
    "    if depth < 0:\n",
    "        return None\n",
    "    path = Path(path).absolute()\n",
    "    if (path / '.git').is_dir():\n",
    "        return path\n",
    "    return find_repo_root(path.parent, depth-1)\n",
    "\n",
    "## Definir a pasta de base do repositório local\n",
    "base_repo_dir = find_repo_root()\n",
    "\n",
    "## Construir caminhos com os.path.join para compatibilidade WSL e Linux\n",
    "folder_utils = os.path.join(base_repo_dir, 'utils')\n",
    "folder_domain = os.path.join(base_repo_dir, 'source', 'domain')\n",
    "folder_data_input = os.path.join(base_repo_dir, '_data', 'in_csv')\n",
    "folder_data_output = os.path.join(base_repo_dir, '_data', 'out_json')\n",
    "sys.path.append(folder_utils)\n",
    "sys.path.append(folder_domain)\n",
    "\n",
    "from environment_setup import EnvironmentSetup\n",
    "from chromedriver_manager import ChromeDriverManager\n",
    "from lattes_scrapper import JSONFileManager, LattesScraper, HTMLParser, SoupParser, GetQualis, ArticlesCounter, DiscentCollaborationCounter, DictToHDF5, attribute_to_be_non_empty\n",
    "from neo4j_persister import Neo4jPersister\n",
    "# from scraper_sucupira_edge import SucupiraScraperEdge\n",
    "# from scraper_sucupira import SucupiraScraper\n",
    "# from scraper_pasteur import PasteurScraper\n",
    "\n",
    "# Carregar para variável dict_list_docents os dicionários com dados dos Docentes\n",
    "jfm = JSONFileManager()\n",
    "jfm.list_json(folder_data_input)\n",
    "filename = 'docents_dict_list.json'\n",
    "\n",
    "## Carregar dicionário temporário de testes\n",
    "# filename = 'temp_dict_list.json'\n",
    "\n",
    "dict_list_docents, formatted_creation_date, formatted_modification_date, time_count, unit = jfm.load_from_json(os.path.join(folder_data_input,filename))\n",
    "print(f\"\\n{len(dict_list_docents)} currículos carregados na lista de dicionários '{filename}'\")\n",
    "print(f\"Arquivo criado inicialmente em {formatted_creation_date}\")\n",
    "print(f\"Última modificação extraída em {formatted_modification_date} há {time_count} {unit}\")\n",
    "\n",
    "lista_nomes_extraidos = [i.get('Identificação').get('Nome') for i in dict_list_docents]\n",
    "lista_nomes_extraidos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8143a095",
   "metadata": {},
   "source": [
    "## Contar artigos e data de atualização dos currículos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b805fd60",
   "metadata": {},
   "source": [
    "### Visualizar quantitativo de artigos extraídos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce2baa2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    scraper.contar_artigos(dict_list_docents)\n",
    "except:\n",
    "    termos_busca = ['Fiocruz', 'Fundação Oswaldo Cruz', 'Biotecnologia', 'RENORBIO', 'saúde']\n",
    "    scraper = LattesScraper(termos_busca, 'bolt://localhost:7687', 'neo4j', 'password', only_doctors=False)\n",
    "    scraper.contar_artigos(dict_list_docents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b135582",
   "metadata": {},
   "source": [
    "### Visualizar quantitativo de artigos extraídos e datas de atualização"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d5a2aee",
   "metadata": {},
   "outputs": [],
   "source": [
    "atualizador = ArticlesCounter(dict_list_docents)\n",
    "dtf_atualizado = atualizador.extrair_data_atualizacao(dict_list_docents)\n",
    "dtf_atualizado"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e31f4ed1",
   "metadata": {},
   "source": [
    "### Verificar indexação no PubMed e no Scielo\n",
    "\n",
    "O PubMed indexa artigos individuais, não revistas inteiras. Embora a maioria dos artigos indexados no PubMed venha de revistas também indexadas no MEDLINE (uma base de dados que lista revistas), existem exceções. Um artigo pode ser incluído no PubMed mesmo que a revista não esteja no MEDLINE, por exemplo, se for de particular importância ou relevância.\n",
    "\n",
    "    A forma mais confiável de verificar se um artigo está no PubMed é buscar diretamente pelo seu DOI (identificador digital de objeto) ou pelo título e autores na própria base de dados do PubMed.\n",
    "\n",
    "A SciELO indexa revistas completas, mas a indexação de uma revista não garante que todos os seus artigos estejam disponíveis na base de dados. A SciELO pode ter critérios adicionais para a inclusão de artigos individuais, como a data de publicação ou o idioma.\n",
    "\n",
    "    Para verificar se um artigo está na SciELO o mais eficiente é buscar pelo título do artigo na SciELO. \n",
    "    \n",
    "Poderia-se ainda buscar pela revista na SciELO e verificar se o artigo específico está incluído na lista de artigos da revista. Ou ainda, usar o DOI do artigo, se a revista oferecer essa funcionalidade.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "752254f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pip install habanero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "209229d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import requests\n",
    "import socket\n",
    "from pprint import pprint\n",
    "from habanero import Crossref\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "def buscar_palavras_chave_scielo(palavras_chave):\n",
    "    \"\"\"\n",
    "    Busca trabalhos relacionados a uma lista de palavras-chave na SciELO.\n",
    "\n",
    "    Args:\n",
    "        palavras_chave (list): Uma lista de palavras-chave para a busca.\n",
    "\n",
    "    Returns:\n",
    "        list: Uma lista de tuplas (título, link) dos artigos encontrados.\n",
    "    \"\"\"\n",
    "\n",
    "    # URL de busca da SciELO\n",
    "    url_busca = \"https://search.scielo.org/?\"\n",
    "\n",
    "    # https://search.scielo.org/?\n",
    "    # q=Alzheimer+Diag*\n",
    "    # &lang=en\n",
    "    # &count=50\n",
    "    # &from=0\n",
    "    # &output=site\n",
    "    # &sort=\n",
    "    # &format=summary\n",
    "    # &fb=\n",
    "    # &page=1\n",
    "\n",
    "    # Construir a query com as palavras-chave\n",
    "    query = \"+\".join([f'\"{palavra}\"' for palavra in palavras_chave])\n",
    "    params = {\n",
    "        \"q\": query,\n",
    "        \"lang\": \"en\",   # Remover a restrição de idioma\n",
    "        \"count\": 100,    # Número de resultados por página\n",
    "        \"from\": 0,\n",
    "        \"output\": \"site\"\n",
    "    }\n",
    "\n",
    "    print(f\"Query montada: {params}\")\n",
    "\n",
    "    # Definir headers com um User-Agent\n",
    "    headers = {\n",
    "        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3' \n",
    "    }\n",
    "\n",
    "    # Fazer a requisição HTTP com headers\n",
    "    response = requests.get(url_busca, params=params, headers=headers)\n",
    "\n",
    "    # Extrair os títulos e links dos artigos\n",
    "    soup = BeautifulSoup(response.content, 'html.parser')\n",
    "    resultados = soup.find_all('div', class_='result')\n",
    "    print(f\"Resultados na base Scielo: {resultados}\")\n",
    "    artigos = []\n",
    "    try:\n",
    "        for resultado in resultados:\n",
    "            titulo = resultado.find('a', class_='doc-title').text.strip()\n",
    "            link = resultado.find('a', class_='doc-title')['href']\n",
    "            artigos.append((titulo, link))\n",
    "    except Exception as e:\n",
    "        print(f\"Erro ao tentar recuperar resultados:\")\n",
    "        print(e)\n",
    "    return artigos\n",
    "\n",
    "def verificar_scielo_por_titulo_ano(titulo, ano):\n",
    "    \"\"\"\n",
    "    Verifica se um artigo está indexado na SciELO usando web scraping (busca por título e ano).\n",
    "\n",
    "    Args:\n",
    "        titulo (str): O título do artigo.\n",
    "        ano (int): O ano de publicação do artigo.\n",
    "\n",
    "    Returns:\n",
    "        bool: True se o artigo for encontrado na SciELO, False caso contrário.\n",
    "    \"\"\"\n",
    "\n",
    "    # URL de busca da SciELO (inicialmente com o nome de domínio)\n",
    "    search_url = \"https://search.scielo.org/?\" \n",
    "    query_params = {\n",
    "        \"q\": titulo,\n",
    "        # \"lang\": \"pt\",  # Para filtrar por linguagem, conforme necessário\n",
    "        \"count\": 10,      # Número de resultados a serem buscados (ajuste conforme necessário)\n",
    "        \"from\": 0,\n",
    "        \"output\": \"site\"\n",
    "    }\n",
    "\n",
    "    # Definir headers e user-agent\n",
    "    headers = {\n",
    "        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3' \n",
    " \n",
    "    }\n",
    "\n",
    "    try:\n",
    "        # Incluir os headers na requisição\n",
    "        response = requests.get(search_url, params=query_params, headers=headers)\n",
    "\n",
    "    except requests.exceptions.RequestException as e:\n",
    "        if isinstance(e, requests.exceptions.ConnectionError) and \"Failed to resolve\" in str(e):\n",
    "            # Se o erro for de resolução de nome, tentar usar o endereço IP\n",
    "            try:\n",
    "                ip_address = socket.gethostbyname('search.scielo.org')\n",
    "                search_url = f\"https://{ip_address}/\"  # Substituir o nome de domínio pelo IP\n",
    "                response = requests.get(search_url, params=query_params, headers=headers)\n",
    "            except socket.gaierror as e:\n",
    "                print(f\"Erro ao obter o endereço IP da SciELO: {e}\")\n",
    "                return False\n",
    "        else:\n",
    "            # Outro tipo de erro na requisição\n",
    "            print(f\"Erro na requisição à SciELO: {e}\")\n",
    "            return False\n",
    "\n",
    "    # Encontrar a seção de resultados\n",
    "    resultados_section_match = re.search(r'<section>.*?<div id=\"ResultArea\">.*?<div class=\"results\">(.*?)</div>', response.text, re.DOTALL)\n",
    "    print(f'Seção busca Scielo: {resultados_section_match}')\n",
    "\n",
    "    if not resultados_section_match:\n",
    "        print(\"Seção de resultados da busca Scielo não encontrada.\")\n",
    "        return False\n",
    "\n",
    "    resultados_section = resultados_section_match.group(1)\n",
    "    print(resultados_section)\n",
    "\n",
    "    # Expressão regular corrigida para capturar todos os elementos filhos dentro de cada resultado\n",
    "    resultados = re.findall(r'<div class=\"item\"[^>]*?>(.*?)</div>', resultados_section, re.DOTALL)\n",
    "\n",
    "    print(resultados)  # Imprimir os resultados para verificar se a captura está funcionando\n",
    "\n",
    "    for resultado in resultados:\n",
    "        # Expressão regular para capturar o título dentro do resultado\n",
    "        titulo_match = re.search(r'<strong class=\"title\"[^>]*?>(.*?)</strong>', resultado, re.DOTALL)\n",
    "        if titulo_match and titulo_match.group(1).lower().strip() == titulo.lower():\n",
    "            # Expressão regular para capturar o ano dentro do resultado\n",
    "            ano_match = re.search(r'(\\d{4})', resultado)  # Busca qualquer sequência de 4 dígitos (ano)\n",
    "            if ano_match and ano_match.group(1).strip() == str(ano):\n",
    "                return True\n",
    "\n",
    "    return False\n",
    "\n",
    "def verificar_indexacao(doi=None, titulo=None, ano=None):\n",
    "    \"\"\"\n",
    "    Verifica se um artigo está indexado nas bases de dados PubMed e SciELO.\n",
    "    Adiciona validação do DOI com o título usando similaridade de Jaccard.\n",
    "\n",
    "    Args:\n",
    "        doi (str, optional): O DOI do artigo.\n",
    "        titulo (str, optional): O título do artigo.\n",
    "        ano (int, optional): O ano de publicação do artigo.\n",
    "\n",
    "    Returns:\n",
    "        tuple: Uma tupla com dois booleanos (PubMed, SciELO) indicando se o artigo está indexado em cada base de dados.\n",
    "    \"\"\"\n",
    "\n",
    "    pubmed_indexado = False\n",
    "    scielo_indexado = False\n",
    "    doi_valido = True  # Assume que o DOI é válido por padrão\n",
    "\n",
    "    if doi:\n",
    "        # Verificar PubMed via Entrez\n",
    "        doi =  doi.replace('https://doi.org/','')\n",
    "        pubmed_url = f\"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term={doi}&retmode=json\"\n",
    "        pubmed_response = requests.get(pubmed_url)\n",
    "        pubmed_data = pubmed_response.json()\n",
    "        print(f\"Dados PubMed\\nDOI: {doi}\\nQte resultados: {pubmed_data['esearchresult']['count']}\")\n",
    "        pubmed_indexado = pubmed_data['esearchresult']['count'] != '0'\n",
    "\n",
    "    ## Fazer busca por dados detalhados usando API Crossref\n",
    "    #     try:\n",
    "    #         cr = Crossref()\n",
    "    #         trabalho = cr.works(ids=doi)[\"message\"]\n",
    "    #         titulo_doi = trabalho['title'][0]\n",
    "    #         print(f\"Título: {titulo_doi}\")\n",
    "    #         print(f\"\\nDados Crossref\")\n",
    "    #         for i,j in trabalho.items():\n",
    "    #             print(f\"{i}: {j}\")\n",
    "\n",
    "    #         # Calcular a similaridade de Jaccard\n",
    "    #         conjunto_titulo = set(titulo.lower().split())\n",
    "    #         # print(conjunto_titulo)\n",
    "    #         conjunto_titulo_doi = set(titulo_doi.lower().split())\n",
    "    #         # print(conjunto_titulo_doi)\n",
    "    #         intersecao = conjunto_titulo.intersection(conjunto_titulo_doi)\n",
    "    #         uniao = conjunto_titulo.union(conjunto_titulo_doi)\n",
    "    #         jaccard_similarity = len(intersecao) / len(uniao)\n",
    "\n",
    "    #         doi_valido = jaccard_similarity > 0.9\n",
    "    #         print(f\"DOI corresponde ao título informado: {doi_valido}\")\n",
    "\n",
    "    #     except Exception as e:\n",
    "    #         print(f\"O Título informado não corresponde ao título do artigo do DOI informado\")\n",
    "    #         print(e)\n",
    "    #         doi_valido = False  # Se houver erro ao obter o título, assume que o DOI não é válido\n",
    "\n",
    "    #     # Verificar SciELO via Crossref (indiretamente)\n",
    "    #     if doi_valido:\n",
    "    #         try:\n",
    "    #             if \"link\" in trabalho:\n",
    "    #                 for link in trabalho[\"link\"]:\n",
    "    #                     if \"scielo\" in link[\"URL\"]:\n",
    "    #                         scielo_indexado = True\n",
    "    #                         break\n",
    "    #         except:\n",
    "    #             pass # Se não encontrar via Crossref, assumir não indexado na SciELO\n",
    "\n",
    "    elif titulo and ano:\n",
    "        # Verificar PubMed via Entrez\n",
    "        pubmed_url = f\"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term={titulo}[Title]+AND+{ano}[Publication Date]&retmode=json\"\n",
    "        pubmed_response = requests.get(pubmed_url)\n",
    "        pubmed_data = pubmed_response.json()\n",
    "        pubmed_indexado = pubmed_data['esearchresult']['count'] != '0'\n",
    "\n",
    "        # Verificar SciELO por título e ano\n",
    "        scielo_indexado = verificar_scielo_por_titulo_ano(titulo, ano)\n",
    "    else:\n",
    "        print('Verificar se o DOI, ou o título e o ano da publicação foram inseridas corretamente')\n",
    "        \n",
    "    # Invalidar resultados se o DOI não for válido\n",
    "    if not doi_valido:\n",
    "        pubmed_indexado = False\n",
    "        scielo_indexado = False\n",
    "\n",
    "    return pubmed_indexado, scielo_indexado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b01cd2df",
   "metadata": {},
   "outputs": [],
   "source": [
    "doi_exemplo = \"https://doi.org/10.1590/S0104-11692008000100023\"\n",
    "titulo_exemplo = \"Aluminum as a risk factor for Alzheimer's disease\"\n",
    "ano_de_publicacao = \"2008\"\n",
    "\n",
    "resultado = verificar_indexacao(doi=doi_exemplo, titulo=titulo_exemplo, ano=2023)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00c3ef2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "buscar_palavras_chave_scielo([\"Alzheimer\", \"Diag*\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08280b49",
   "metadata": {},
   "outputs": [],
   "source": [
    "resultado = verificar_indexacao(titulo=titulo_exemplo, ano=ano_de_publicacao)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19b28630",
   "metadata": {},
   "source": [
    "# <b>F02: Listar Orientações por tipos</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8739ce50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [x for x in dict_list_docents[0].get('Orientações')]\n",
    "# [x for x in dict_list_docents[19].get('Orientações')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "70d728ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Gera a lista de orientações\n",
    "orientacoes_lista = scraper.organizar_orientacoes_geral(dict_list_docents)\n",
    "\n",
    "# Create the DataFrame\n",
    "df_orientacoes = pd.DataFrame(orientacoes_lista).sort_values(by=['Docente','status','tipo','ano'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3162a49d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filtrar a lista de orientações\n",
    "orientacoes_roberto_nicolete = [\n",
    "    orientacao\n",
    "    for orientacao in orientacoes_lista\n",
    "    if scraper.remover_acentos(orientacao['Docente']).lower() == 'roberto nicolete'\n",
    "]\n",
    "\n",
    "tipos = [\n",
    "    'Dissertação de mestrado',\n",
    "    'Tese de doutorado'\n",
    "]\n",
    "status = [\n",
    "    'em andamento',\n",
    "    'concluídas'\n",
    "]\n",
    "\n",
    "count=0\n",
    "print(f\"{len(orientacoes_roberto_nicolete)} orientações no total\")\n",
    "# Imprimir o resultado\n",
    "for n,orientacao in enumerate(orientacoes_roberto_nicolete):\n",
    "    if orientacao.get('tipo') in tipos and orientacao.get('status') in status:\n",
    "        count+=1\n",
    "        print(f\"{n+1:2} | {orientacao.get('ano')} {orientacao.get('tipo'):30} | {orientacao.get('instituicao').split(',')[0]:45} | {orientacao.get('orientando'):45} | {orientacao.get('status')}\")\n",
    "print(f\"{count} dissertações de mestrado ou teses de doutorado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5cae889",
   "metadata": {},
   "outputs": [],
   "source": [
    "k=1\n",
    "df_orientacoes[k:k+600]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "730b6533",
   "metadata": {},
   "source": [
    "# Contar orientações onde há Fiocruz, ou não há"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17c24816",
   "metadata": {},
   "outputs": [],
   "source": [
    "tipos_aceitaveis = [\n",
    "                    'Dissertação de mestrado',\n",
    "                    'Tese de doutorado',\n",
    "                    # 'Iniciação científica',\n",
    "                    # 'Monografia',\n",
    "                    # 'Trabalho de conclusão de curso de graduação',\n",
    "                    # 'Monografia de conclusão de curso de aperfeiçoamento/especialização',\n",
    "                    # 'Orientação de outra natureza',\n",
    "                    # 'Orientações de outra natureza',\n",
    "                    # 'Trabalho de Conclusão de Curso',\n",
    "                    ]\n",
    "\n",
    "# Use a função para gerar a tabela dinâmica\n",
    "ano_inicio = 2019\n",
    "ano_final  = 2025\n",
    "\n",
    "# Gera a lista de orientações\n",
    "orientacoes_lista = scraper.organizar_orientacoes_geral(dict_list_docents)\n",
    "\n",
    "# Gera o dataframe de contagens\n",
    "dataframe_contagens = scraper.criar_dataframe_contagens(orientacoes_lista, ano_inicio, ano_final, tipos_aceitaveis)\n",
    "\n",
    "# Exibe o dataframe\n",
    "dataframe_contagens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96415476",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gera a lista de orientações\n",
    "orientacoes_lista = scraper.organizar_orientacoes_geral(dict_list_docents)\n",
    "\n",
    "# Gera o relatório em HTML\n",
    "html_report = scraper.generate_html_report(orientacoes_lista)\n",
    "\n",
    "with open('relatorio_orientacoes.html', 'w', encoding='utf-8') as f:\n",
    "    f.write(html_report)\n",
    "\n",
    "print(\"Relatório em HTML gerado com sucesso: relatorio_orientacoes.html\")\n",
    "\n",
    "# Gera o relatório em PDF\n",
    "# generate_pdf_report(html_report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a0b220d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, HTML\n",
    "\n",
    "display(HTML(html_report))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ff7f4fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemplo de uso\n",
    "dados_profissionais = dict_list_docents[5]['Orientações']\n",
    "dados_profissionais\n",
    "# # Garante que dados_profissionais seja uma lista\n",
    "# if not isinstance(dados_profissionais, list):\n",
    "#     dados_profissionais = [dados_profissionais]\n",
    "\n",
    "# tempo_atuacao, atuacoes_em_curso = calcular_tempo_atuacao(dados_profissionais)\n",
    "\n",
    "# print(tempo_atuacao)\n",
    "# print(atuacoes_em_curso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ace11c",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_list_docents[19].get('Orientações')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e655163",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_instituicoes = [x.get('Instituição') for x in dict_list_docents[19].get('Atuação Profissional')]\n",
    "instituicoes_unicas = list(set(lista_instituicoes))\n",
    "instituicoes_unicas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6044afd1",
   "metadata": {},
   "source": [
    "# <b>F03: Avaliar pontuação currículos de Orientadores</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24d6a96e",
   "metadata": {},
   "source": [
    "## Produções dentro do Período 2020 a 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9739b690",
   "metadata": {},
   "source": [
    "Calcular conforme os seguintes indicadores:\n",
    "\n",
    "### 1. Artigos Publicados em Periódicos\tPontuação\n",
    "\n",
    "- Fator de Impacto JCR ≥ 1,01\t                      x 8 pontos\n",
    "- Fator de Impacto JCR entre 0,51 e 1,0\t              x 6 pontos\n",
    "\n",
    "(Não contabilizado) Inclusão na base de dados Scielo\t                x 1 ponto\n",
    "\n",
    "(Não contabilizado) Inclusão na base de dados Web of Science ou Pubmed  x 2 pontos \n",
    "\n",
    "Obs: Artigos incluídos em mais de uma base cientifica recebem 2 pontos relativos a maior pontuação, sem acúmulo.\n",
    "\n",
    "### 2. Trabalhos Publicados em Eventos Científicos\tPontuação\n",
    "\n",
    "- Resumo Estendido/ Artigo Completo (teto 5 trabalhos) x 2 pontos\n",
    "- Resumo Simples (teto 10 trabalhos)\t               x 1 ponto\n",
    "\n",
    "### 3. Livros\t\n",
    "\n",
    "- Livro Publicado com ISBN (mínimo 80 páginas)\t       x 3 pontos\n",
    "- Organização de Livro\t                               x 3 pontos\n",
    "- Capítulo de Livro\t                                   x 2 pontos\n",
    "\n",
    "### 4. Softwares e Patentes\t\n",
    "\n",
    "- Registro de Softwares\t\t                           x 2 pontos\n",
    "- Pedido de patente depositada no INPI\t               x 3 pontos\n",
    "- Pedido de patente deferido pelo INPI\t               x 4 pontos\n",
    "\n",
    "### 5. Orientações Concluídas\t\n",
    "\n",
    "- Tese de Doutorado\t                                   x 2 pontos\n",
    "- Dissertação de Mestrado\t                           x 2 pontos\n",
    "- TCC (teto 10 TCCs)\t                               x 1 ponto\n",
    "\n",
    "### 6. Orientações Concluídas de IC\t\n",
    "\n",
    "- PIBIC/PIBIT/FUNCAP/CNPq\t                           x 1 ponto\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba6e5abc",
   "metadata": {},
   "source": [
    "## Avaliar pontuações para Edital 2024/01 Fiocruz Ceará"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "df0dcfa4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Definir os anos do período de interesse\n",
    "# ano_inicio = 2020\n",
    "# ano_final = 2024\n",
    "\n",
    "# ## Definir a lista de orientadores que se inscreveram no Edital\n",
    "# orientadores = [\n",
    "#     'JAIME RIBEIRO FILHO',\n",
    "#     'REGIS BERNARDO BRANDIM GOMES',\n",
    "#     'FABIO MIYAJIMA',\n",
    "#     'ROBERTO NICOLETE',\n",
    "#     'MARCOS ROBERTO LOURENZONI',\n",
    "#     'JOÃO HERMINIO MARTINS DA SILVA',\n",
    "#     'ANA CAROLINA MATIAS DINELLY PINTO',\n",
    "#     'GILVAN PESSOA FURTADO',\n",
    "#     'GERALDO RODRIGUES SARTORI',\n",
    "#     'ELAINE SILVA NASCIMENTO ANDRADE',\n",
    "#     'CECILI BARROZO MENDES',\n",
    "#     'CHRISTIANE FRANÇA MARTINS',\n",
    "#     'KETLEN CHRISTINE OHSE',\n",
    "#     'CLARISSA PERDIGÃO MELLO FERRAZ',\n",
    "#     'ALLYSSON ALLAN DE FARIAS',\n",
    "#     'JÚLIO CESAR MARTINS XIMENES',\n",
    "#     'DONAT ALEXANDER DE CHAPEAUROUGE',\n",
    "#     'ADRIANA COSTA BACELO',\n",
    "# ]\n",
    "\n",
    "# df_geral, df_orientadores = atualizador.calcular_pontuacoes(dict_list_docents, ano_inicio, ano_final, orientadores_filtro=orientadores)\n",
    "# print(f'Apuração da pontuação nos currículos de orientadores, conforme Edital 2024/01 Fiocruz Ceará, referente produções dentro do período {ano_inicio} a {ano_final}')\n",
    "# df_orientadores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "51941855",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'Apuração geral de pontuação, conforme Edital 2024/01 Fiocruz Ceará, referente produções dentro do período {ano_inicio} a {ano_final}')\n",
    "# df_geral"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cd0088d",
   "metadata": {},
   "source": [
    "# <b>F04: Avaliar áreas de atuação e especialidade"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f76f8a8",
   "metadata": {},
   "source": [
    "### Investigar dicionários na estrutura de dados gerada com currículos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "02f68f34",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver detalhes de forma recursiva em uma determinada estrutura de dados em dicionários aninhados\n",
    "def avaliar_tipo_instancias_arvore(estrutura_dados, nivel=1, identacao=\"\"):\n",
    "    \"\"\"\n",
    "    Função recursiva que avalia o tipo e a quantidade de instâncias em cada nível da estrutura de dados, exibindo-a em formato de árvore.\n",
    "\n",
    "    Args:\n",
    "        estrutura_dados (list|dict): A estrutura de dados a ser avaliada.\n",
    "        nivel (int): Nível atual da recurssão (inicia em 1).\n",
    "        identacao (str): String de indentação para cada nível (inicia vazia).\n",
    "\n",
    "    Returns:\n",
    "        None: A função imprime os resultados na tela e não retorna nada.\n",
    "    \"\"\"\n",
    "\n",
    "    if isinstance(estrutura_dados, list):\n",
    "        print(f\"{identacao}N{nivel}. Lista: {len(estrutura_dados)} elementos\")\n",
    "        for item in estrutura_dados:\n",
    "            avaliar_tipo_instancias_arvore(item, nivel + 1, identacao + \"    \")\n",
    "\n",
    "    elif isinstance(estrutura_dados, dict):\n",
    "        print(f\"{identacao}N{nivel}. Mapa: {estrutura_dados.keys()}\")\n",
    "        for chave, valor in estrutura_dados.items():\n",
    "            print(f\"{identacao}  {chave}:\")\n",
    "            avaliar_tipo_instancias_arvore(valor, nivel + 1, identacao + \"    \")\n",
    "\n",
    "    elif isinstance(estrutura_dados, str):\n",
    "        print(f\"{identacao}N{nivel}. String: {estrutura_dados}\")\n",
    "\n",
    "## Ver somente chaves de subdicionário de segundo nível na chave de primeiro nível e dicionário passado como parâmetro\n",
    "from pprint import pprint\n",
    "\n",
    "def contar_subchaves(dict_list_docents, chave_dicionario):\n",
    "    qte_maxsubkeys=0\n",
    "    max_subkeys=[]\n",
    "    for n,j in enumerate([x.get(chave_dicionario).keys() for x in dict_list_docents]):\n",
    "        nome = dict_list_docents[n].get(chave_dicionario).get(subchave_dicionario)\n",
    "        max_subkeys.append((n, len(list(j))))\n",
    "        if len(list(j)) >= qte_maxsubkeys:\n",
    "            qte_maxsubkeys = len(list(j))\n",
    "            curriculo_maxsubkeys = dict_list_docents[n].get('Identificação').get('Nome')\n",
    "    print(max_subkeys)\n",
    "    return curriculo_maxsubkeys, qte_maxsubkeys\n",
    "\n",
    "def ver_subchaves(dict_list_docents, chave_dicionario):\n",
    "    for n,j in enumerate([x.get(chave_dicionario).keys() for x in dict_list_docents]):\n",
    "        nome = dict_list_docents[n].get('Identificação').get('Nome')\n",
    "        print('-'*125)\n",
    "        print(nome)\n",
    "        pprint(list(j))\n",
    "\n",
    "def ver_conteudo_lista(dict_list_docents, chave_dicionario):\n",
    "    for n,j in enumerate([x.get(chave_dicionario) for x in dict_list_docents]):\n",
    "        nome = dict_list_docents[n].get('Identificação').get('Nome')\n",
    "        print('-'*125)\n",
    "        print(nome)\n",
    "        pprint(list(j), width=125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25eb66dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Varrer cada dicionário na lista de dicionários carregada do arquivo de extração salvo localmente\n",
    "for dict_pesq in dict_list_docents[:3]:\n",
    "    avaliar_tipo_instancias_arvore(dict_pesq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07de54d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_chaves = []\n",
    "for curriculum in dict_list_docents:\n",
    "    keys_one = list(curriculum.keys())\n",
    "    for i in keys_one:\n",
    "        if i not in todas_chaves:\n",
    "            todas_chaves.append(i)\n",
    "todas_chaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7b3fc9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in dict_list_docents[1].get('Identificação').keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60dd12f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in dict_list_docents[1].get('Áreas').values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f8702f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in dict_list_docents[5].get('Atuação Profissional')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85a55055",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from datetime import date\n",
    "today = date.today()\n",
    "today\n",
    "\n",
    "today == date.fromtimestamp(time.time())\n",
    "\n",
    "my_birthday = date(today.year, 8, 11)\n",
    "if my_birthday < today:\n",
    "    my_birthday = my_birthday.replace(year=today.year + 1)\n",
    "\n",
    "my_birthday\n",
    "\n",
    "time_to_birthday = abs(my_birthday - today)\n",
    "time_to_birthday.days"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d573841a",
   "metadata": {},
   "source": [
    "## Listar as áreas de atuação e linhas de pesquisa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a9a78de",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "\n",
    "def listar_linhas(lista_dicionarios, key_one, key_two=None):\n",
    "    dict_linhas = {}\n",
    "    linhas_geral = set()  # Use um conjunto para evitar duplicatas\n",
    "    if key_two:\n",
    "        print('LINHAS DE ATUAÇÃO DE CADA PESQUISADOR:')\n",
    "    else:\n",
    "        print('ÁREAS DO CNPq DE CADA PESQUISADOR:')\n",
    "    for curriculo in lista_dicionarios:\n",
    "        idlattes = curriculo.get('Identificação', {}).get('ID Lattes')\n",
    "        nome = curriculo.get('Identificação', {}).get('Nome')\n",
    "        if not nome:  # Verifica se o nome existe\n",
    "            continue  # Pula para o próximo currículo se não houver nome\n",
    "\n",
    "        # Filtra valores nulos e usa conjunto para evitar duplicatas\n",
    "        if key_two:\n",
    "            linhas_pesquisador = list(set(x.get(key_two) for x in curriculo.get(key_one, []) if x.get(key_two)))\n",
    "        else:\n",
    "            linhas_pesquisador = list(set(x for x in curriculo.get(key_one, []).values() if x)) \n",
    "\n",
    "        dict_linhas[nome] = linhas_pesquisador  # Adiciona ao dicionário corretamente\n",
    "        linhas_geral.update(linhas_pesquisador)  # Adiciona ao conjunto geral\n",
    "\n",
    "        print('=' * 125)\n",
    "        print(f'{idlattes}: {nome}')\n",
    "        for i in linhas_pesquisador:\n",
    "            print(f'  - {i}')\n",
    "\n",
    "    return list(linhas_geral)  # Converte o conjunto em lista para retornar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8e548a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_dicionarios = dict_list_docents\n",
    "key_one = 'Áreas'\n",
    "key_two = None\n",
    "areas_cnpq_ict = listar_linhas(lista_dicionarios, key_one, key_two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b794a7c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_dicionarios = dict_list_docents\n",
    "key_one = 'Linhas de Pesquisa'\n",
    "key_two = 'Descrição'\n",
    "linhas_pesquisa_ict = listar_linhas(lista_dicionarios, key_one, key_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b3fcb32",
   "metadata": {},
   "source": [
    "## Listar atuação profissional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7e2e2c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_list_docents[19].get('Atuação Profissional')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee12f50",
   "metadata": {},
   "source": [
    "## Calcular tempos de atuação em cada instituição"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "086cdc86",
   "metadata": {},
   "source": [
    "### TO-DO: Corrigir: calcular_tempo_atuacao [GERANDO ERRO NO SOMATÓRIO DOS TEMPOS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6de7930e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "from dateutil.parser import parse\n",
    "\n",
    "def calcular_tempo_atuacao(dados_profissionais):\n",
    "    \"\"\"Calcula o tempo de atuação em cada instituição e destaca as atuações em curso.\n",
    "\n",
    "    Args:\n",
    "        dados_profissionais: Lista de dicionários com dados de atuações profissionais.\n",
    "\n",
    "    Returns:\n",
    "        Um dicionário com o tempo de atuação total em cada instituição e as atuações em curso.\n",
    "    \"\"\"\n",
    "\n",
    "    tempo_atuacao = {}\n",
    "    atuacoes_em_curso = []\n",
    "    ano_corrente = datetime.now().year\n",
    "\n",
    "    for atuacao in dados_profissionais:\n",
    "        instituicao = atuacao['Instituição']\n",
    "        ano = atuacao['Ano']\n",
    "\n",
    "        # Substitui \"Atual\" pelo ano corrente\n",
    "        if \"Atual\" in ano:\n",
    "            ano = ano.replace(\"Atual\", str(ano_corrente))\n",
    "\n",
    "        try:\n",
    "            inicio, fim = map(parse, ano.split(' - '))\n",
    "        except ValueError:\n",
    "            try:\n",
    "                inicio, fim = map(lambda x: datetime.strptime(x, \"%Y\"), ano.split(' - '))\n",
    "            except ValueError:\n",
    "                print(f\"Aviso: Formato de data inválido em '{ano}'. Pulando...\")\n",
    "                continue\n",
    "\n",
    "        em_curso = \"Atual\" in atuacao['Ano']  # Verifica se a atuação está em curso\n",
    "\n",
    "        tempo_total = (fim.year - inicio.year) * 12 + (fim.month - inicio.month) + 1\n",
    "        tempo_atuacao[instituicao] = tempo_atuacao.get(instituicao, 0) + tempo_total // 12\n",
    "\n",
    "        if em_curso:\n",
    "            atuacoes_em_curso.append(f\"{instituicao} ({inicio.year} - Atual)\")\n",
    "\n",
    "    return tempo_atuacao, atuacoes_em_curso\n",
    "\n",
    "# Dicionário para armazenar o tempo total em cada instituição\n",
    "tempo_atuacao_total = {}\n",
    "# Lista para armazenar as atuações em curso\n",
    "atuacoes_em_curso_total = []\n",
    "\n",
    "# Itera sobre os dicionários em dict_list_docents\n",
    "for entrada in dict_list_docents:\n",
    "    # print(type(dict_list_docents))\n",
    "    # print(type(entrada))\n",
    "    if type(entrada) is dict and 'Identificação' in entrada and 'Atuação Profissional' in entrada:\n",
    "\n",
    "        nome = entrada['Identificação']['Nome']\n",
    "        dados_profissionais = entrada['Atuação Profissional']\n",
    "\n",
    "        # Se dados_profissionais não for uma lista, transforma em lista\n",
    "        if not isinstance(dados_profissionais, list):\n",
    "            dados_profissionais = [dados_profissionais]\n",
    "\n",
    "        tempo_atuacao, atuacoes_em_curso = calcular_tempo_atuacao(dados_profissionais)\n",
    "\n",
    "        # Imprime o nome da pessoa\n",
    "        print(nome)\n",
    "        print()  # Adiciona uma linha em branco\n",
    "\n",
    "        # Imprime o tempo de atuação em cada instituição\n",
    "        print(\"Tempo de atuação em cada instituição:\")\n",
    "        for instituicao, tempo in tempo_atuacao.items():\n",
    "            print(f\"{tempo:2} anos | {instituicao}\")\n",
    "\n",
    "        # Imprime as atuações em curso\n",
    "        print(\"\\nAtuações em curso:\")\n",
    "        for atuacao in atuacoes_em_curso:\n",
    "            print(f\"- {atuacao}\")\n",
    "\n",
    "        # Imprime uma linha separadora\n",
    "        print(\"-\" * 125)  # Imprime 30 traços\n",
    "        print()  # Adiciona uma linha em branco\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ee6353d",
   "metadata": {},
   "source": [
    "## Quantificar tipos de experiências profissionais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce609fad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time, numpy as np\n",
    "from datetime import date\n",
    "\n",
    "def get_funcao(string_vinculo):\n",
    "    funcao=None\n",
    "    try:\n",
    "        funcao = string_vinculo.split(':')[2].replace(', Carga horária','').replace(',','').strip()\n",
    "        if 'Professor' in funcao:\n",
    "            funcao = 'Ensino'\n",
    "        elif 'Pesquisador' in funcao:\n",
    "            funcao = 'Pesquisa'\n",
    "        elif 'Bolsista' in funcao:\n",
    "            funcao = 'Bolsista'\n",
    "        elif 'Monitor' in funcao:\n",
    "            funcao = 'Monitor'\n",
    "        elif 'Supervisor' in funcao:\n",
    "            funcao -'Supervisor'\n",
    "        elif 'Técnica' in funcao:\n",
    "            funcao -'Técnica'\n",
    "        elif 'Direção' in funcao:\n",
    "            funcao = 'Direção'\n",
    "        elif 'Assessoria' in funcao:\n",
    "            funcao = 'Assessoria'\n",
    "        else:\n",
    "            funcao = 'Outras'\n",
    "    except:\n",
    "        if 'Professora Colaboradora' in string_vinculo:\n",
    "            funcao = 'Ensino'\n",
    "        elif 'Ensino' in string_vinculo:\n",
    "            funcao = 'Ensino'\n",
    "        elif 'técnico' in string_vinculo:\n",
    "            funcao = 'Técnica'\n",
    "        elif 'Extensão universitária' in string_vinculo:\n",
    "            funcao = 'Extensão'\n",
    "        elif 'Supervisor' in string_vinculo:\n",
    "            funcao = 'Supervisão'\n",
    "        elif 'Pesquisa e desenvolvimento' in string_vinculo:\n",
    "            funcao = 'Pesquisa'\n",
    "        elif 'Direção' in string_vinculo:\n",
    "            funcao = 'Direção'\n",
    "        elif 'Treinamento' in string_vinculo:\n",
    "            funcao = 'Treinamento'\n",
    "        else:\n",
    "            funcao = 'Outras'\n",
    "            print(string_vinculo)\n",
    "    return funcao\n",
    "\n",
    "def get_tempo(string_periodo):\n",
    "    inicio, fim = string_periodo.split(' - ')\n",
    "    if '/' in inicio:\n",
    "        inicio = float(inicio.split('/')[1])+(float(inicio.split('/')[0])/12)\n",
    "    else:\n",
    "        inicio = float(inicio)\n",
    "    if 'Atual' in fim:\n",
    "        fim = float(today.year)+float(today.month)/12\n",
    "    elif '/' in fim:\n",
    "            fim = float(fim.split('/')[1])+(float(fim.split('/')[0])/12)\n",
    "    else:\n",
    "        fim = float(fim)\n",
    "    \n",
    "    anos = np.round(fim - inicio, 1)\n",
    "    return anos\n",
    "\n",
    "instituicoes = [x.get('Instituição') for x in dict_list_docents[1].get('Atuação Profissional')]\n",
    "periodos = [x.get('Ano') for x in dict_list_docents[1].get('Atuação Profissional')]\n",
    "vinculos = [x.get('Outras informações') for x in dict_list_docents[1].get('Atuação Profissional')]\n",
    "today = date.today()\n",
    "experiencias = []\n",
    "for i,p,v in zip(instituicoes,periodos,vinculos):\n",
    "    funcao = get_funcao(v)\n",
    "    anos = get_tempo(p)\n",
    "    if anos.is_integer() or anos < 10:  # Adiciona a condição anos < 10\n",
    "        print(f'Durante {p:^17} {anos:0>4.1f} anos em função {funcao:11} | {i}')  # Exibe com dois dígitos e uma casa decimal\n",
    "    else:\n",
    "        print(f'Durante {p:^17} {anos:.1f} anos em função {funcao:11} | {i}')  # Exibe com uma casa decimal (sem zero à esquerda)\n",
    "\n",
    "    experiencias.append((i, p, anos))\n",
    "experiencias "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71767842",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,p,a in experiencias:\n",
    "    instituicao = i.split('-')[0].split(',')[0]\n",
    "    print(instituicao)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bb66084",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_list_docents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "800219b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "dicionarios_interesse = [\n",
    "    'Identificação',\n",
    "    'Formação',\n",
    "    'Atuação Profissional',\n",
    "    'Linhas de Pesquisa',\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e3ab85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# curriculo_maxsubkeys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a212c1d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_list_docents[17].get('Identificação').get('Nome')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af3a777a",
   "metadata": {},
   "source": [
    "## Obter as palavras-chave predominantes nos currículos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adb68253",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f6db076e",
   "metadata": {},
   "source": [
    "### Explorar conteúdo de dicionários extraídos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc814821",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver chaves de dicionário de primeiro nível no arquivo de dados\n",
    "from pprint import pprint\n",
    "\n",
    "max_keys=[]\n",
    "for n,i in enumerate([x.keys() for x in dict_list_docents]):\n",
    "    max_keys.append((n, len(list(i))))\n",
    "print(max_keys)\n",
    "pprint(list(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "156662b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver chaves de subdicionário de segundo nível no dicionário 'Produções' do arquivo de dados\n",
    "from pprint import pprint\n",
    "\n",
    "max_subkeys=[]\n",
    "for n,j in enumerate([x.get('Produções').keys() for x in dict_list_docents]):\n",
    "    max_subkeys.append((n, len(list(j))))\n",
    "print(max_subkeys)\n",
    "pprint(list(j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aaf7989",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver chaves de subdicionário de segundo nível no dicionário 'Produções' do arquivo de dados\n",
    "# Chamar a função recursiva para cada dicionário na lista, filtrando por \"Orientações\"\n",
    "# chave='Orientações'\n",
    "# for docente in dict_list_docents:\n",
    "#     atualizador.imprimir_chaves_recursivo(docente, nivel1_filtro=chave)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a53054b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver quantidade de chaves de subdicionário do dicionário de Produções, segundo nível no arquivo de dados\n",
    "# max_subkeys=[]\n",
    "# for n,i in enumerate([x.get('Produções').keys() for x in dict_list_docents]):\n",
    "#     max_subkeys.append((n,len(list(i))))\n",
    "# print(max_subkeys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c2e5359",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Ver anos de cada uma das publicações dos artigos completos em periódicos\n",
    "# for n,i in enumerate([x for x in dict_list_docents]):\n",
    "#     try:\n",
    "#         artigos = i.get('Produções').get('Artigos completos publicados em periódicos')\n",
    "#         anos = [x.get('ano') for x in artigos]\n",
    "#         print(anos)\n",
    "#     except:\n",
    "#         print('Artigos não encontrados para este currículo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a52f9174",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_points\n",
    "# [x.get('Orientações') for x in dict_list_docents]\n",
    "\n",
    "# import re\n",
    "# import collections\n",
    "# from pprint import pprint\n",
    "# tipos=[]\n",
    "\n",
    "# # Verificar orientações concluídas de IC nos dados de docentes\n",
    "# for i in [x.get('Orientações').get('Orientações e supervisões concluídas') for x in dict_list_docents if x.get('Orientações')]:\n",
    "#     if i is not None:\n",
    "#         for tipo in i:\n",
    "#             if tipo.keys() not in tipos:\n",
    "#                 tipos.append(tipo.keys()) \n",
    "#             try:\n",
    "#                 qic = tipo.get('Dissertação de mestrado')\n",
    "#             except:\n",
    "#                 qic = 0\n",
    "#             if qic:\n",
    "#                 lista = [x for x in qic.values()]\n",
    "#     else:\n",
    "#         qic = 0\n",
    "\n",
    "# for i in tipos:\n",
    "#     print(list(i)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4577e6a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "# Leitura de todas as chaves e subchaves de dicionários\n",
    "todas_chaves_principais = []\n",
    "todas_subchaves_producoes = []\n",
    "todas_subchaves_patentes = []\n",
    "todas_subchaves_orientacoes = []\n",
    "ano_inicial = 2020\n",
    "ano_termino = 2024\n",
    "verbose = False\n",
    "for x in dict_list_docents:\n",
    "    chaves_dicionarios = [c for c in x]\n",
    "    for i in chaves_dicionarios:\n",
    "        if i not in todas_chaves_principais:\n",
    "            todas_chaves_principais.append(i)\n",
    "    dict_id = x.get('Identificação')\n",
    "    dict_prods = x.get('Produções')\n",
    "    dict_orients = x.get('Orientações')\n",
    "    dict_patents = x.get('Patentes e registros')\n",
    "    lista_subchaves_producoes=[x for x in dict_prods.keys()]\n",
    "    lista_subchaves_orientacoes=[x for x in dict_orients.keys()]\n",
    "    lista_subchaves_patentes=[x for x in dict_patents.keys()]\n",
    "    for i in lista_subchaves_producoes:\n",
    "        if i not in todas_subchaves_producoes:\n",
    "            todas_subchaves_producoes.append(i)\n",
    "    for i in lista_subchaves_orientacoes:\n",
    "        if i not in todas_subchaves_orientacoes:\n",
    "            todas_subchaves_orientacoes.append(i)\n",
    "    for i in lista_subchaves_patentes:\n",
    "        if i not in todas_subchaves_patentes:\n",
    "            todas_subchaves_patentes.append(i)\n",
    "    ## Subdciocionários por tipos de produções\n",
    "    artigos = dict_prods.get('Artigos completos publicados em periódicos')\n",
    "    livros_publicados = dict_prods.get('Livros publicados/organizados ou edições')\n",
    "    capitulos_livros  = dict_prods.get('Capítulos de livros publicados')\n",
    "    organizacao_livro = dict_prods.get('Capítulos de livros publicados')\n",
    "    trabalho_congresso = dict_prods.get('Trabalhos completos publicados em anais de congressos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a72e98",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_chaves_principais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6793b465",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_subchaves_producoes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07d6bfcd",
   "metadata": {},
   "source": [
    "## Patentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f130f2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_subchaves_patentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9628717",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_patentes = []\n",
    "for x in dict_list_docents:\n",
    "    nome = x.get('Identificação').get('Nome')\n",
    "    patentes_registros = x.get('Patentes e registros')\n",
    "    todas_patentes.append((nome,patentes_registros))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c40e07f",
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_patentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fb009bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Pontuação geral por artigos publicados ponderados pelo JCR no período {ano_inicio} a {ano_final}')\n",
    "df_artigos_geral = df_resultado.sort_values(by=['Total Pontos'], ascending=False)\n",
    "df_artigos_geral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26a7dacc",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "# Leitura de todas as chaves e subchaves de dicionários\n",
    "todas_chaves_principais = []\n",
    "todas_subchaves_producoes = []\n",
    "todas_subchaves_orientacoes = []\n",
    "ano_inicial = 2020\n",
    "ano_termino = 2024\n",
    "verbose = False\n",
    "for x in dict_list_docents:\n",
    "    chaves_dicionarios = [c for c in x]\n",
    "    for i in chaves_dicionarios:\n",
    "        if i not in todas_chaves_principais:\n",
    "            todas_chaves_principais.append(i)\n",
    "    dict_id = x.get('Identificação')\n",
    "    dict_prods = x.get('Produções')\n",
    "    dict_orients = x.get('Orientações')\n",
    "    lista_subchaves_producoes=[x for x in dict_prods.keys()]\n",
    "    lista_subchaves_orientacoes=[x for x in dict_orients.keys()]\n",
    "    for i in lista_subchaves_producoes:\n",
    "        if i not in todas_subchaves_producoes:\n",
    "            todas_subchaves_producoes.append(i)\n",
    "    for i in lista_subchaves_orientacoes:\n",
    "        if i not in todas_subchaves_orientacoes:\n",
    "            todas_subchaves_orientacoes.append(i)\n",
    "\n",
    "    ## Subdciocionários por tipos de produções\n",
    "    artigos = dict_prods.get('Artigos completos publicados em periódicos')\n",
    "    livros_publicados = dict_prods.get('Livros publicados/organizados ou edições')\n",
    "    capitulos_livros  = dict_prods.get('Capítulos de livros publicados')\n",
    "    organizacao_livro = dict_prods.get('Capítulos de livros publicados')\n",
    "    trabalho_congresso = dict_prods.get('Trabalhos completos publicados em anais de congressos')\n",
    "    patentes_registros = dict_prods.get('Patentes e registros')\n",
    "\n",
    "    ### CONTAGENS\n",
    "    ## Contagem da publicação de artigos em periódicos\n",
    "    qte_jcr_faltante=0\n",
    "    qte_jcr_inferior=0\n",
    "    qte_jcr_superior=0\n",
    "    pontos_artsemjci = 0\n",
    "    pontos_artjcimenor = 0\n",
    "    pontos_artjcimaior = 0\n",
    "    pontos_public=0\n",
    "    \n",
    "    artigos_todos_tempos=0\n",
    "    artigos_dentro_periodo=0\n",
    "    \n",
    "    if artigos:\n",
    "        if verbose:        \n",
    "            print(f'Dicionário de artigos:')\n",
    "            pprint(artigos, width=120)\n",
    "        for i in artigos:\n",
    "            artigos_todos_tempos+=1\n",
    "            try:\n",
    "                try:\n",
    "                    ano_artigo = int(i.get('ano'))\n",
    "                except:\n",
    "                    ano_artigo = ano_inicial\n",
    "                if ano_inicial <= ano_artigo <= ano_termino:\n",
    "                    artigos_dentro_periodo+=1\n",
    "                    try:\n",
    "                        impacto = float(i.get('fator_impacto_jcr'))\n",
    "                        if impacto>=0.5:\n",
    "                            qte_jcr_inferior+=1\n",
    "                        elif impacto>=1.1:\n",
    "                            qte_jcr_superior+=1\n",
    "                    except:\n",
    "                        qte_jcr_faltante+=1                      \n",
    "            except Exception as e:\n",
    "                print(f'        Erro ao extrair artigo: {e}')\n",
    "                print(f'        Artigo com problema: {i}')\n",
    "\n",
    "    qte_artperiodicos=qte_jcr_faltante+qte_jcr_inferior+qte_jcr_superior\n",
    "\n",
    "    ## Contagem da publicação de livros e capítulos\n",
    "    qte_livros=0\n",
    "    qte_capitulos=0\n",
    "    pontos_livpub=0\n",
    "    pontos_capliv=0\n",
    "    if livros_publicados:\n",
    "        if verbose:        \n",
    "            print(f'Dicionário de livros:')\n",
    "            pprint(livros_publicados)\n",
    "        qte_livros = len([x for x in livros_publicados])\n",
    "    if capitulos_livros:\n",
    "        qte_capitulos = len([x for x in capitulos_livros])\n",
    "    \n",
    "    ## Contagem de Orientações Concluídas\n",
    "    qte_ic=0\n",
    "    qte_grad=0\n",
    "    qte_espec=0\n",
    "    qte_mest=0\n",
    "    qte_dout=0\n",
    "    qte_orientacoes_total=0\n",
    "    qte_orientacoes=0\n",
    "    pontos_orient_ic=0\n",
    "    pontos_orient_grad=0\n",
    "    pontos_orient_mest=0\n",
    "    pontos_orient_dout=0\n",
    "    pontos_orient=0\n",
    "\n",
    "    concluidas = dict_orients.get('Orientações e supervisões concluídas')\n",
    "    if concluidas:\n",
    "        if verbose:\n",
    "            print(f'Dicionário de orientações concluídas:')\n",
    "            pprint(concluidas, width=120)\n",
    "        for i in concluidas:\n",
    "            dict_ic = i.get('Iniciação científica')\n",
    "            if dict_ic:\n",
    "                try:\n",
    "                    for chave, valor in dict_ic.items():\n",
    "                        qte_orientacoes_total+=1\n",
    "                        ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "                        if ano_match:\n",
    "                            ano_orientacao = int(ano_match.group(1))\n",
    "                            if ano_inicial <= ano_orientacao <= ano_termino:\n",
    "                                qte_orientacoes+=1                    \n",
    "                                qte_ic += 1\n",
    "                except Exception as e:\n",
    "                    print(f'        Erro em extração de IC: {e}')\n",
    "            dict_grad = i.get('Trabalho de conclusão de curso de graduação')\n",
    "            if dict_grad:\n",
    "                try:\n",
    "                    for chave, valor in dict_grad.items():\n",
    "                        qte_orientacoes_total+=1\n",
    "                        ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "                        if ano_match:\n",
    "                            ano_orientacao = int(ano_match.group(1))\n",
    "                            if ano_inicial <= ano_orientacao <= ano_termino:\n",
    "                                qte_orientacoes+=1                      \n",
    "                                qte_grad += 1\n",
    "                except Exception as e:\n",
    "                    print(f'        Erro em extração de Graduação: {e}')\n",
    "            dict_espe = i.get('Monografia de conclusão de curso de aperfeiçoamento/especialização')\n",
    "            if dict_espe:\n",
    "                try:\n",
    "                    for chave, valor in dict_espe.items():\n",
    "                        qte_orientacoes_total+=1\n",
    "                        ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "                        if ano_match:\n",
    "                            ano_orientacao = int(ano_match.group(1))\n",
    "                            if ano_inicial <= ano_orientacao <= ano_termino:\n",
    "                                qte_orientacoes+=1                      \n",
    "                                qte_espec +=1\n",
    "                except Exception as e:\n",
    "                    qte_espec = 0\n",
    "                    print(f'        Erro em extração de Especialização: {e}')   \n",
    "            dict_mest = i.get('Dissertação de mestrado')\n",
    "            if dict_mest:\n",
    "                try:\n",
    "                    for chave, valor in dict_mest.items():\n",
    "                        qte_orientacoes_total+=1\n",
    "                        ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "                        if ano_match:\n",
    "                            ano_orientacao = int(ano_match.group(1))\n",
    "                            if ano_inicial <= ano_orientacao <= ano_termino:\n",
    "                                qte_orientacoes+=1  \n",
    "                                qte_mest +=1\n",
    "                except Exception as e:\n",
    "                    print(f'        Erro em extração de Mestrado: {e}')\n",
    "            dict_dout = i.get('Tese de doutorado')\n",
    "            if dict_dout:                \n",
    "                try:\n",
    "                    for chave, valor in dict_dout.items():\n",
    "                        qte_orientacoes_total+=1\n",
    "                        ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "                        if ano_match:\n",
    "                            ano_orientacao = int(ano_match.group(1))\n",
    "                            if ano_inicial <= ano_orientacao <= ano_termino:\n",
    "                                qte_orientacoes+=1                      \n",
    "                                qte_dout +=1\n",
    "                except Exception as e:\n",
    "                    print(f'        Erro em extração de Doutorado: {e}')\n",
    "\n",
    "        qte_tcc = qte_grad+qte_espec\n",
    "\n",
    "    ## Contagem dos Trabalhos completos publicados em anais de congressos\n",
    "    qte_trabcongresso_total=0\n",
    "    qte_trabcongresso=0\n",
    "    pontos_congresso=0\n",
    "    if trabalho_congresso:\n",
    "        if verbose:\n",
    "            print(f'Dicionário de trabalhos em congressos:')\n",
    "            pprint(trabalho_congresso, width=120)        \n",
    "        qte_trabcongresso_total = len([x for x in trabalho_congresso])\n",
    "        for chave, valor in trabalho_congresso.items():\n",
    "            ano_match = re.search(r'\\b(\\d{4})\\b', valor)\n",
    "            if ano_match:\n",
    "                ano_trabalho = int(ano_match.group(1))\n",
    "                if ano_inicial <= ano_trabalho <= ano_termino:\n",
    "                    qte_trabcongresso+=1\n",
    "    \n",
    "    ### PONDERAÇÕES\n",
    "    ## Ponderação das Publicações de artigos completos em periódicos\n",
    "    pontos_artsemjci = qte_jcr_faltante*0\n",
    "    pontos_artjcimenor = qte_jcr_inferior*6\n",
    "    pontos_artjcimaior = qte_jcr_superior*8\n",
    "    pontos_public = pontos_artsemjci+pontos_artjcimenor+pontos_artjcimaior\n",
    "\n",
    "    ## Ponderação das Publicações de Livros e Capítulos\n",
    "    # - Livro publicado com ISBN = 3p (mínimo 80 páginas)\n",
    "    # - Organização de livro     = x 3p\n",
    "    # - Capítulo de livro        = x 2p\n",
    "    pontos_livpub = qte_livros*3\n",
    "    pontos_capliv = qte_capitulos*2\n",
    "    pontos_livros = pontos_livpub+pontos_capliv\n",
    "\n",
    "    ## Ponderações de Trabalhos publicados em anais de congressos\n",
    "    # - Resumo Estendido/ Artigo Completo (teto 5 trabalhos) x 2 pontos\n",
    "    # - Resumo Simples (teto 10 trabalhos)\t                 x 1 ponto\n",
    "    pontos_congresso = qte_trabcongresso*2\n",
    "    if pontos_congresso>10:\n",
    "        pontos_congresso=10\n",
    "\n",
    "    ## Ponderação das Orientações\n",
    "    # Orientações Concluídas\t\n",
    "    # - Tese de Doutorado\t       x 2 pontos\n",
    "    # - Dissertação de Mestrado\t   x 2 pontos\n",
    "    # - TCC (teto 10 TCCs)\t       x 1 ponto\n",
    "    # Orientações Concluídas de IC \n",
    "    # - PIBIC/PIBIT/FUNCAP/CNPq\t   x 1 ponto    \n",
    "    pontos_orient_ic+=qte_ic*1\n",
    "    pontos_orient_grad+=qte_tcc*1\n",
    "    if pontos_orient_grad > 10:\n",
    "        pontos_orient_grad = 10\n",
    "    pontos_orient_mest+=qte_mest*2\n",
    "    pontos_orient_dout+=qte_dout*2\n",
    "  \n",
    "    ## Totalização dos pontos\n",
    "    pontos_orient=pontos_orient_ic+pontos_orient_grad+pontos_orient_mest+pontos_orient_dout\n",
    "\n",
    "    ## IMPRESSÃO   \n",
    "    print('='*125)\n",
    "    print(dict_id.get('Nome'))\n",
    "    print(f'    {qte_trabcongresso:3} Trabalhos publicados em congresso no período do edital (de um total de {qte_trabcongresso_total})')    \n",
    "    print(f'    {qte_artperiodicos:3} Artigos publicados em perióridos  no período do edital (de um total de {artigos_todos_tempos})')\n",
    "    print(f'    {qte_orientacoes:3} Orientações acadêmicas concluídas no periodo do edital (de um total de {qte_orientacoes_total})')\n",
    "    # print(f'    {pontos_orient_ic:02} pontos por orientar {qte_ic:02} alunos de Iniciação Científica: ')\n",
    "    # print(f'    {pontos_orient_grad:02} pontos por orientar {qte_tcc:02} alunos de Graduação/Especialização')\n",
    "    # pontos_orient_mest = qte_mest*2\n",
    "    # print(f'    {pontos_orient_mest:02} pontos por orientar {qte_mest:02} alunos de Mestrados')\n",
    "    # pontos_orient_dout = qte_dout*2\n",
    "    # print(f'    {pontos_orient_dout:02} pontos por orientar {qte_dout:02} alunos de Doutorados')\n",
    "\n",
    "    print(f'{pontos_public+pontos_livros+pontos_congresso+pontos_orient:4} pontos no total, detalhados conforme a seguir:')\n",
    "    print(f'    {pontos_public:4}pnt por publicar artigo completo: {qte_jcr_superior:02} JCI >= 1.1; {qte_jcr_inferior:02} JCI entre 0.5 a 1.1; {qte_jcr_faltante:02} sem JCI no Lattes')\n",
    "    print(f'    {pontos_livros:4}pnt por publicar livro/capitulos: {qte_livros:02} livro completo publicado/organizado; {qte_capitulos:02} capítulos de livros publicado')\n",
    "    print(f'    {pontos_congresso:4}pnt por trabalho publ. congresso: {qte_trabcongresso:02} trabalhos publicados em anais de congressos')\n",
    "    print(f'    {pontos_orient:4}pnt por todas orientações concl.: {qte_ic:02} iniciação científica; {qte_tcc:02} graduações/especialização; {qte_mest:02} mestrados; {qte_dout:02} doutorados')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0938fbba",
   "metadata": {},
   "outputs": [],
   "source": [
    "chaves_producoes = ['Artigos completos publicados em periódicos', \n",
    "                    'Citações', \n",
    "                    'Capítulos de livros publicados', \n",
    "                    'Resumos expandidos publicados em anais de congressos', \n",
    "                    'Resumos publicados em anais de congressos', \n",
    "                    'Resumos publicados em anais de congressos (artigos)', \n",
    "                    'Artigos  aceitos para publicação', \n",
    "                    'Apresentações de Trabalho', \n",
    "                    'Assessoria e consultoria', \n",
    "                    'Programas de computador sem registro', \n",
    "                    'Produtos tecnológicos', \n",
    "                    'Trabalhos técnicos', \n",
    "                    'Entrevistas, mesas redondas, programas e comentários na mídia'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bffcd492",
   "metadata": {},
   "outputs": [],
   "source": [
    "j = {'Tese de doutorado': {'1.': 'Anna Carolina Machado Marinho. Expressão, caracterização estrutural e ensaios de estabilidade de nanocorpos e construtos relacionados, com vistas ao incremento da soroterapia antiofídica. Início: 2020. Tese (Doutorado em Doutorado em Ciências Farmacêuticas da Universidade Federal do Ceará)  - Fundação Oswaldo Cruz CE. (Orientador).'}}\n",
    "len([x for x in j.get('Tese de doutorado')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95371713",
   "metadata": {},
   "outputs": [],
   "source": [
    "artigos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a3c2878",
   "metadata": {},
   "outputs": [],
   "source": [
    "livros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5de9b430",
   "metadata": {},
   "outputs": [],
   "source": [
    "trabalhos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8274323",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "for x in dict_list_docents:\n",
    "    dict_prods = x.get('Produções')\n",
    "    # pprint([x for x in dict_prods.keys()])\n",
    "    if dict_prods:\n",
    "        tecnologias = [dict_prods.get('Produtos tecnológicos')]\n",
    "        ignorar = ['curso','plano','protocolo ']\n",
    "        if tecnologias:\n",
    "            if \n",
    "            print(tecnologias)\n",
    "    else:\n",
    "        print('Produtos tecnológicos não encontrados')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08764c92",
   "metadata": {},
   "outputs": [],
   "source": [
    "tipos=[]\n",
    "\n",
    "for i in [x.get('Livros publicados/organizados ou edições') for x in dict_list_docents if x.get('Livros publicados/organizados ou edições')]:\n",
    "    if i is not None:\n",
    "        for tipo in i:\n",
    "            if tipo.keys() not in tipos:\n",
    "                tipos.append(tipo.keys()) \n",
    "            try:\n",
    "                qic = tipo.get('Dissertação de mestrado')\n",
    "            except:\n",
    "                qic = 0\n",
    "            if qic:\n",
    "                lista = [x for x in qic.values()]\n",
    "    else:\n",
    "        print('Subchaves não encontradas')\n",
    "        qic = 0\n",
    "\n",
    "for i in tipos:\n",
    "    print(list(i)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc120078",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import collections\n",
    "from pprint import pprint\n",
    "tipos=[]\n",
    "\n",
    "producoes_subkeys = ['Artigos completos publicados em periódicos', \n",
    "    'Citações',\n",
    "    'Livros publicados/organizados ou edições',\n",
    "    'Capítulos de livros publicados',\n",
    "    'Trabalhos completos publicados em anais de congressos',\n",
    "    'Resumos expandidos publicados em anais de congressos',\n",
    "    'Resumos publicados em anais de congressos',\n",
    "    'Apresentações de Trabalho',\n",
    "    'Assessoria e consultoria',\n",
    "    'Trabalhos técnicos',\n",
    "    'Entrevistas, mesas redondas, programas e comentários na mídia']\n",
    "\n",
    "# Verificar orientações concluídas de IC nos dados de docentes\n",
    "for i in [x.get('Orientações').get('Orientações e supervisões concluídas') for x in dict_list_docents if x.get('Orientações')]:\n",
    "    if i is not None:\n",
    "        for tipo in i:\n",
    "            if tipo.keys() not in tipos:\n",
    "                tipos.append(tipo.keys()) \n",
    "            try:\n",
    "                qic = tipo.get('Dissertação de mestrado')\n",
    "            except:\n",
    "                qic = 0\n",
    "            if qic:\n",
    "                lista = [x for x in qic.values()]\n",
    "    else:\n",
    "        qic = 0\n",
    "\n",
    "for i in tipos:\n",
    "    print(list(i)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1519396",
   "metadata": {},
   "outputs": [],
   "source": [
    "keylevel_one = 'Produções'\n",
    "keylevel_two = 'Artigos completos publicados em periódicos'\n",
    "data_measure = 'fator_impacto_jcr'\n",
    "curriculo_id = 44\n",
    "ano_inicio = 2020\n",
    "ano_final = 2024\n",
    "\n",
    "class_mapping = {\n",
    "    '0p (sem JCR)': 0,\n",
    "    '6p (0.5 < JCR <= 1.0)': 0,\n",
    "    '8p (JCR > 1.0)': 0\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "516f894a",
   "metadata": {},
   "source": [
    "## Obter Grupos de Pesquisa no DGP/CNPq "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "500222ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "# os.listdir('C:\\\\Users\\\\marco\\\\Downloads')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38c25969",
   "metadata": {},
   "outputs": [],
   "source": [
    "## montar um dataframe com nomes dos membros dos grupos de pesquisa do DGP CNPq\n",
    "folder_download = 'C:\\\\Users\\\\marco\\\\Downloads'\n",
    "def montardf_dgp():\n",
    "    try:\n",
    "        file = 'dgp2023_grupos_pesquisa.csv'\n",
    "        pathfilename = os.path.join(folder_download, file)\n",
    "        print(pathfilename)\n",
    "\n",
    "        # Especifique a codificação correta (substitua 'latin-1' pela codificação real do seu arquivo)\n",
    "        df_dgp = pd.read_csv(pathfilename, header=0, encoding='latin-1')  \n",
    "\n",
    "    except Exception as e:\n",
    "        print('Erro ao ler o arquivo CSV:')\n",
    "        print(e)\n",
    "        return\n",
    "\n",
    "    return df_dgp\n",
    "\n",
    "def montardf_participantes_dgp():\n",
    "    try:\n",
    "        file = 'dgp2023_participantes_grupos_pesquisa.csv'\n",
    "        pathfilename = os.path.join(folder_download, file)\n",
    "        print(pathfilename)\n",
    "\n",
    "        # Especifique a codificação correta (substitua 'latin-1' pela codificação real do seu arquivo)\n",
    "        df_dgp = pd.read_csv(pathfilename, header=0, encoding='latin-1')  \n",
    "\n",
    "    except Exception as e:\n",
    "        print('Erro ao ler o arquivo CSV:')\n",
    "        print(e)\n",
    "        return\n",
    "\n",
    "    return df_dgp\n",
    "\n",
    "df_dgp = montardf_dgp()\n",
    "print(f'Chaves do arquivo de grupos: {df_dgp.keys()}')\n",
    "\n",
    "df_participantes = montardf_participantes_dgp()\n",
    "print(f'Chaves do arquivo de participantes: {df_participantes.keys()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80a2cf58",
   "metadata": {},
   "outputs": [],
   "source": [
    "filtro_instituicao = df_dgp['SIGLA_DA_INSTITUICAO'] == 'FIOCRUZ'\n",
    "dfdgp_fiocruz = df_dgp[filtro_instituicao]\n",
    "print(f'{len(dfdgp_fiocruz.index)} grupos de pesquisa da Fiocruz Nacional')\n",
    "# dfdgp_fiocruz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4005bb1",
   "metadata": {},
   "source": [
    "### Dados dos grupos de pesquisa Fiocruz Ceará"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9754f2f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_espelhos = [\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/368850',\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/773438',\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/192437',\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/0837407474908287',\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/772170',\n",
    "    'https://dgp.cnpq.br/dgp/espelhogrupo/662667',\n",
    "    'http://dgp.cnpq.br/dgp/espelhogrupo/528799']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d98c4103",
   "metadata": {},
   "outputs": [],
   "source": [
    "filtro_estado = df_dgp['UF_GRUPO_PESQUISA'] == 'Ceará'\n",
    "dfdgp_fiocruz_ce = dfdgp_fiocruz[filtro_estado]\n",
    "dfdgp_fiocruz_ce = dfdgp_fiocruz_ce.drop(columns=['DATA_INICIO_DA_COLETA','DATA_FIM_DA_COLETA','REGIAO_GRUPO_PESQUISA','UF_GRUPO_PESQUISA','CIDADE_GRUPO_PESQUISA','NOME_DA_INSTITUICAO','NATUREZA_JURIDICA','ANO_DO_CENSO','CATEGORIA_ADMINISTRATIVA'])\n",
    "\n",
    "print(f'{len(dfdgp_fiocruz_ce.index)} grupos de pesquisa da Fiocruz no Ceará')\n",
    "nomes_grupos_fioce = list(dfdgp_fiocruz_ce['NOME_DO_GRUPO'])\n",
    "nomes_grupos_fioce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05065851",
   "metadata": {},
   "outputs": [],
   "source": [
    "dfdgp_fiocruz_ce.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ff21768",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dfdgp_fiocruz_ce.keys())\n",
    "dfdgp_fiocruz_ce.columns=['IDENTIFICADOR','NOME_GRUPO','ANO_FORM','GRANDE_AREA','AREA','SIGLA','SETOR_ECONOMICO','LINHAS','PESQUISADORES','ESTUDANTES','TECNICOS','COLABORADORES','DOUTORES','DOUTORANDOS','MESTRANDOS','GRADUANDOS']\n",
    "dfdgp_fiocruz_ce"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dd88235",
   "metadata": {},
   "source": [
    "### Listar membros de cada Grupo de Pesquisa do DGP/CNPq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7339710",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dfdgp_ce['SIGLA_DA_INSTITUICAO'].unique()\n",
    "# df_dgp['CIDADE_GRUPO_PESQUISA'].unique()\n",
    "# filtro_instituicao_ceara = dfdgp_ce['SIGLA_DA_INSTITUICAO'] == 'FIOCRUZ'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80d1155f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c37260ed",
   "metadata": {},
   "source": [
    "# <b>F05: Avaliar programa de pós PPGCS Fiocruz-MG</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "385bad8a",
   "metadata": {},
   "source": [
    "## Indicadores do Programa PPGCS"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e9addac",
   "metadata": {},
   "source": [
    "### 1. Pontuação por Fator de Impacto (PFI >=600)\n",
    "- Meta: PFI >= 600 em pelo menos 70% dos docentes\n",
    "\n",
    "    Indicador: Total de pontos conforme periódicos das publicações no período\n",
    "     Objetivo: Publicar trabalhos em periódicos de elevado impacto\n",
    "               \n",
    "         Meta: 70% dos docentes permanentes com PFI >= 600 pontos no quadriênio\n",
    "               (150/ano e ao menos 03 artigos A, no mínimo 02 em A1, ou 04 artigos A2);\n",
    " \n",
    "      Cálculo: Soma ponderada pela estratificação Qualis de acordo com o que segue:\n",
    "        A1 = 100 pontos\n",
    "        A2 = 80 pontos\n",
    "        B1 = 60 pontos\n",
    "        B2 = 40 pontos\n",
    "        B3 = 20 pontos\n",
    "        B4 = 10 pontos\n",
    "        B5 = 2 pontos.\n",
    "\n",
    "\n",
    "Parâmetro para classificaçao do periódico:\n",
    "\n",
    "        A1: FI Periódico ou CPD >= 4,300\n",
    "        A2: FI Periódico ou CPD entre 2,950 e 4,299\n",
    "        B1: FI Periódico ou CPD entre 1,800 e 2,949\n",
    "        B2: FI Periódico ou CPD entre 1,100 e 1,799\n",
    "        B3: FI Periódico ou CPD entre 0,300 e 1,099\n",
    "        B4: FI Periódico ou CPD entre 0,001 e 0,299, (ou Scielo, Scimago, PubMed ou Web of Science)\n",
    "        B5: Periódicos sem FI ou CPD e indexado nas lases Lilacs ou Latindex    \n",
    "\n",
    "### 2. Produção Conjunta docentes/discentes (IPC >= 50%):\n",
    "    Indicador: Índice de publicações com discentes por orientador (IPC)\n",
    "     Objetivo: Em, pelo menos, 50 % dos artigos publicados deve constar discentes do programa\n",
    "         Meta: IPC >= 50,00\n",
    "      \n",
    "      Cálculo:\n",
    "\n",
    "$$\\sum_{k=1}^{n}\\, 100 * \\frac{QPCD}{QPAT}$$\n",
    "\n",
    "        onde:\n",
    "               n = Artigos completos publicado em periódicos indexados\n",
    "            QPCD = Qte. Publicação de Artigos com discentes do Programa na lista de autores\n",
    "            QPAT = Qte. Publicação de Artigos Total no período avaliado\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ac30bb",
   "metadata": {},
   "source": [
    "## Ponderação por extrato Qualis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af7b0023",
   "metadata": {},
   "source": [
    "#### Contar artigos estratificados pelo Qualis Periódicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e83d4d81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definir os anos do período de interesse\n",
    "ano_inicio = 2020\n",
    "ano_final = 2024\n",
    "atualizador.contar_qualis(dict_list_docents, ano_inicio, ano_final)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7950622",
   "metadata": {},
   "source": [
    "#### Classificar artigos no período pelo Qualis Periódicos\n",
    "\n",
    "Obs.: 'Não encontrado' significa que o ISSN da revista da publicação não consta na lista de revistas avaliadas no Qualis Periódico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e969d0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definir os anos do período de interesse\n",
    "ano_inicio = 2020\n",
    "ano_final = 2024\n",
    "atualizador.apurar_qualis_periodo(dict_list_docents, ano_inicio, ano_final).fillna('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ba17bb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definir os anos do período de interesse\n",
    "ano_inicio = 2020\n",
    "ano_final = 2024\n",
    "df_pontuacao = atualizador.apurar_pontos_periodo(dict_list_docents, ano_inicio, ano_final)\n",
    "df_pontuacao"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922feca2",
   "metadata": {},
   "source": [
    "# <b>F06: Obter produções dos Discentes do programa</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19872560",
   "metadata": {},
   "source": [
    "## Montar lista_busca para dados de Discentes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a39722ea",
   "metadata": {},
   "source": [
    "### Carregar nomes de planilha com dados de Discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "391dac31",
   "metadata": {},
   "outputs": [],
   "source": [
    "preparer = EnvironmentSetup()\n",
    "discent_collab_counter = DiscentCollaborationCounter(dict_list_docents)\n",
    "\n",
    "# fonte_planilha = 'ppgcs_estudantes_2021-2024.xlsx'\n",
    "fonte_planilha = 'fioce_lista_alunos.xlsx'\n",
    "dados_discentes = pd.read_excel(os.path.join(LattesScraper.find_repo_root(),'_data','in_xls',fonte_planilha), header=0)\n",
    "dados_discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d00d9ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ler dados do arquivo Excel do Setor de Recursos Humanos\n",
    "pathdata = '_data/in_xls/'\n",
    "datasheet = 'fioce_lista_alunos.xlsx'\n",
    "\n",
    "# Ler apenas os cabeçalhos do arquivo Excel\n",
    "headers = pd.read_excel(pathdata+datasheet, skiprows=0, header=0, nrows=0).columns\n",
    "# headers\n",
    "\n",
    "# Indicar quais colunas devem ser eliminadas na leitura\n",
    "def cols_to_keep(col_name):\n",
    "    return col_name not in []\n",
    "\n",
    "# Filtrar cabeçalhos com base na função\n",
    "selected_columns = [col for col in headers if cols_to_keep(col)]\n",
    "\n",
    "# Ler dados do arquivo Excel do Setor de Recursos Humanos\n",
    "fioce_alunos = pd.read_excel(pathdata+datasheet, skiprows=0, header=0, usecols=selected_columns)\n",
    "print(f'{len(fioce_alunos.index)} quantidade total de alunos, todos vínculos e status')\n",
    "print(f'{len(fioce_alunos[\"nome\"].unique()):3} nomes únicos')\n",
    "\n",
    "print('\\nTipos de vínculos',list(fioce_alunos['vinculo'].unique()))\n",
    "print(f\"Quantidades por Nível de graduação\\n{fioce_alunos['vinculo'].value_counts()}\")\n",
    "\n",
    "print('\\n  Tipos de status',list(fioce_alunos['ativo'].unique()))\n",
    "print('Quantidades por Tipos de status\\n',(fioce_alunos['ativo'].value_counts()))\n",
    "filtro1 = fioce_alunos['vinculo'].isin(['Graduação', 'Mestrado', 'Doutorado', 'Pós-Doc', 'Profsaúde'])\n",
    "filtro2 = fioce_alunos['ativo'].isin([True, False])\n",
    "# filtro2 = fioce_alunos['ativo'].isin([True])\n",
    "lista_nomes = fioce_alunos[(filtro1) & (filtro2)]['nome'].unique().tolist()\n",
    "\n",
    "print(f'\\n{len(lista_nomes)} nomes de alunos em todos os status')\n",
    "lista_busca_alunos = []\n",
    "for i,nome in enumerate(lista_nomes):\n",
    "    if nome.strip().title() not in lista_busca_alunos:\n",
    "        lista_busca_alunos.append(nome.strip().title())\n",
    "        print(f'{i+1:2}. {nome.title()}')\n",
    "\n",
    "print(f'\\n{len(lista_busca_alunos)} nomes únicos de alunos para extrair currículos')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd233282",
   "metadata": {},
   "source": [
    "## <b>Processar extração de dados de Discentes</b>\n",
    "    (~80min/93nomes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1f53916",
   "metadata": {},
   "outputs": [],
   "source": [
    "# discent_collab_counter = DiscentCollaborationCounter(dict_list_docents)\n",
    "# print(f'{len(lista_busca_alunos)} discentes relacionados aos programas')\n",
    "\n",
    "# lista_normalizada_discentes=[]\n",
    "# for i in lista_busca_alunos:\n",
    "#     lista_normalizada_discentes.append(discent_collab_counter.iniciais_nome(i))\n",
    "\n",
    "# t1 = time.time()\n",
    "# termos_busca = ['Cruz', 'Família', 'Biotecnologia', 'Ceará']\n",
    "# scraper = LattesScraper(termos_busca, \n",
    "#                         'bolt://localhost:7687', 'neo4j', 'password', \n",
    "#                         only_doctors=False)\n",
    "\n",
    "# # Extrai e monta JSON com a lista de dicionários\n",
    "# discents_dict_list = scraper.scrape(lista_busca_alunos, termos_busca)\n",
    "# print(f'\\n{scraper.tempo(t1,time.time())} para busca de {len(lista_busca_alunos)} nomes com extração de dados de {len(discents_dict_list)} dicionários')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae95f24b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## Contagem de artigos para simples confererência\n",
    "# print(f'{len(discents_dict_list)} dicionários montados')\n",
    "# qte_artigos=0\n",
    "# qte_titulos=0\n",
    "# for k,i in enumerate(discents_dict_list):\n",
    "#     try:\n",
    "#         qte_jcr = len(i.get('Produções').get('Artigos completos publicados em periódicos'))\n",
    "#     except:\n",
    "#         qte_jcr = 0\n",
    "#     try:\n",
    "#         qte_jcr2 = len(i['JCR2'])\n",
    "#     except:\n",
    "#         qte_jcr2 = 0\n",
    "\n",
    "#     qte_artigos+=qte_jcr\n",
    "#     qte_titulos+=qte_jcr2\n",
    "#     status=qte_jcr2-qte_jcr\n",
    "#     print(f\"{k:>2}C {qte_jcr:>03}A {qte_jcr2:>03}T Dif:{status:>03} {i.get('Identificação').get('name')} \")\n",
    "\n",
    "# print(f'\\nTotal de artigos em todos períodos: {qte_artigos}')\n",
    "# print(f'Total de títulos em todos períodos: {qte_titulos}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72ee9510",
   "metadata": {},
   "source": [
    "### Identificar currículos remanescentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19d50745",
   "metadata": {},
   "outputs": [],
   "source": [
    "# termos_busca = ['Cruz', 'Família', 'Biotecnologia', 'Ceará']\n",
    "# lista_restante = scraper.avaliar_remanescentes(lista_busca_alunos, discents_dict_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff94827d",
   "metadata": {},
   "source": [
    "### Adicionar nomes ou novos termos, se necessário"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27ddca0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # lista_restante.append('Caroline Pereira Bittencourt Passaes')\n",
    "# for i in lista_restante:\n",
    "#     print(f'   {i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8a0e284",
   "metadata": {},
   "source": [
    "### Extrair currículos remanescentes ou adicionais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a58b181",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # lista_dict_combinado = extract_remanescents(lista_restante, dict_list_actual)\n",
    "# lista_dict_combinado = scraper.extract_remanescents(lista_restante, discents_dict_list, termos_busca)\n",
    "# filepath = os.path.join(folder_data_input,'dict_list_discents.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f30b62ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(f'{len(lista_dict_combinado)} dicionários de discentes extraídos')\n",
    "# try:\n",
    "#     exemplo = [x.get('Produções') for x in lista_dict_combinado][0].get('Artigos completos publicados em periódicos')[0]\n",
    "#     if exemplo:\n",
    "#         print('\\n\\nExemplo de dados dos artigos:')\n",
    "#         print(exemplo)\n",
    "# except:\n",
    "#     pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6063e67",
   "metadata": {},
   "outputs": [],
   "source": [
    "from lattes_scrapper import GetQualis\n",
    "stratifier = GetQualis()\n",
    "\n",
    "# Acrescentar Qualis periódicos aos dicionários de docentes\n",
    "print('\\nAdicionando Qualis Periódicos')\n",
    "pathfilename = os.path.join(folder_data_input,'discents_dict_list.json')\n",
    "stratifier.buscar_qualis_e_atualizar_arquivo(lista_dict_combinado, pathfilename)\n",
    "scraper.save_to_json(lista_dict_combinado, pathfilename)\n",
    "\n",
    "print(f'{len(lista_dict_combinado)} dicionários com currículos completos extraídos')\n",
    "print('\\n\\nExemplo de dados dos artigos:')\n",
    "try:\n",
    "    exemplo = [x.get('Produções') for x in lista_dict_combinado][0].get('Artigos completos publicados em periódicos')[0]\n",
    "    if exemplo:\n",
    "        print('\\n\\nExemplo de dados dos artigos:')\n",
    "        print(exemplo)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bd1f79a",
   "metadata": {},
   "source": [
    "## Ler dados salvos de Discentes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bc99d37",
   "metadata": {},
   "source": [
    "### Listar arquivos salvos na pasta de entrada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15d44b34",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_data_input = os.path.join(os.getcwd(),'_data','in_csv')\n",
    "os.listdir(folder_data_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22e72eea",
   "metadata": {},
   "source": [
    "### Carregar dados completos dos Discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83177667",
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'discents_dict_list.json'\n",
    "pathfilename = os.path.join(folder_data_input, filename)\n",
    "dict_list_discents, formatted_creation_date, formatted_modification_date, time_count, unit = jfm.load_from_json(pathfilename)\n",
    "print(f'{len(dict_list_discents)} Total de currículos extaídos')\n",
    "[i.get('Identificação').get('Nome') for i in dict_list_discents]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7838e245",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verificar orientações nos dados de docentes\n",
    "# [x.get('Orientações') for x in dict_list_discents if x.get('Orientações')]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "583cd37f",
   "metadata": {},
   "source": [
    "## <b>Avaliar colaboração discente/docentes</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8666c42c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for dic in dict_list_discents:\n",
    "#     a = dic.get('Produções', {}).get('Artigos completos publicados em periódicos', {})\n",
    "#     print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e25a3a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#### TO-DO #### corrigir busca pelo nome de discentes nos dados de pulicação de docentes.\n",
    "discent_collab_counter = DiscentCollaborationCounter(dict_list_docents)\n",
    "colaboracoes, percentuais = discent_collab_counter.get_articles_coauthorings(dict_list_docents, ano_inicio=2017, ano_final=2024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4e90742",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(colaboracoes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "001bbb3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(percentuais)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5b0bdc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df_pontuacao.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91c7954f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Acrescentar a coluna de percentual de colaboração docente/discente\n",
    "df_pontuacao['colab_disc'] = percentuais\n",
    "filepath = os.path.join(os.path.join(\"./\",\"_data\",\"powerbi\",'fioce_prodpubl_2017_2024.xlsx'))\n",
    "df_pontuacao.to_excel(filepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f886d8b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'{len(df_pontuacao.index)} pesquisadores')\n",
    "df_pontuacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b12f804b",
   "metadata": {},
   "outputs": [],
   "source": [
    "pathfilename = os.path.join(os.path.join(\"./\",\"_data\",\"powerbi\",'fioce_prodpubl_discentcollab_2017_2024.xlsx'))\n",
    "df_pontuacao.to_excel(pathfilename)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17da8026",
   "metadata": {},
   "source": [
    "## <b>Acrescentar Qualis Periódicos</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36721f73",
   "metadata": {},
   "source": [
    "### Abrir dados localmente de Docentes e Discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8802f09d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from getpass import getpass\n",
    "from datetime import datetime\n",
    "from pprint import pprint\n",
    "from IPython.display import clear_output\n",
    "import pandas as pd, os, re, sys, time, pytz, json, subprocess\n",
    "\n",
    "## Configurar exibição do pandas para melhor visualizar os dados\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "pd.set_option('colheader_justify', 'left')\n",
    "pd.set_option('display.max_rows', 600)\n",
    "\n",
    "def find_repo_root(path='.', depth=10):\n",
    "    ''' \n",
    "    Busca o arquivo .git e retorna string com a pasta raiz do repositório\n",
    "    '''\n",
    "    # Limitar profundidade para evitar loop infinito\n",
    "    if depth < 0:\n",
    "        return None\n",
    "    path = Path(path).absolute()\n",
    "    if (path / '.git').is_dir():\n",
    "        return path\n",
    "    return find_repo_root(path.parent, depth-1)\n",
    "\n",
    "## Definir a pasta de base do repositório local\n",
    "base_repo_dir = find_repo_root()\n",
    "\n",
    "## Sempre construir os caminhos usando os.path.join para compatibilidade WxL\n",
    "folder_utils = os.path.join(base_repo_dir, 'utils')\n",
    "folder_domain = os.path.join(base_repo_dir, 'source', 'domain')\n",
    "folder_data_xls = os.path.join(base_repo_dir, '_data', 'in_xls')\n",
    "folder_data_input = os.path.join(base_repo_dir, '_data', 'in_csv')\n",
    "folder_data_output = os.path.join(base_repo_dir, '_data', 'output')\n",
    "\n",
    "## Adicionar pastas locais ao sys.path para importar pacotes criados localmente\n",
    "sys.path.append(folder_utils)\n",
    "sys.path.append(folder_domain)\n",
    "from scraper_pasteur import PasteurScraper\n",
    "from environment_setup import EnvironmentSetup\n",
    "from scraper_sucupira import SucupiraScraper\n",
    "from scraper_sucupira_edge import SucupiraScraperEdge\n",
    "from chromedriver_manager import ChromeDriverManager\n",
    "from neo4j_persister import Neo4jPersister\n",
    "from lattes_scrapper import JSONFileManager, LattesScraper, HTMLParser, SoupParser, GetQualis, ArticlesCounter, DiscentCollaborationCounter, DictToHDF5, attribute_to_be_non_empty\n",
    "\n",
    "# Carregar o conteúdo do arquivo 'dict_list.json' para a variável dict_list\n",
    "jfm = JSONFileManager()\n",
    "jfm.list_json(folder_data_input)\n",
    "\n",
    "# Carregar o conteúdo do arquivo da extração de docentes para a variável dict_list_docents\n",
    "filename_docents = 'docents_dict_list.json'\n",
    "dict_list_docents, formatted_creation_date, formatted_modification_date, time_count, unit = jfm.load_from_json(os.path.join(folder_data_input,filename_docents))\n",
    "\n",
    "print(f\"\\n{len(dict_list_docents)} currículos carregados na lista de dicionários de docentes '{filename_docents}'\")\n",
    "print(f\"Arquivo criado inicialmente em {formatted_creation_date} carregado com sucesso\")\n",
    "print(f\"Extração realizada em {formatted_modification_date} a {time_count} {unit}\")\n",
    "print('\\nExemplo dos dados das publicações de docentes:')\n",
    "pprint([x.get('Produções') for x in dict_list_docents][-1].get('Artigos completos publicados em periódicos')[0])\n",
    "\n",
    "# Carregar o conteúdo do arquivo da extração de discentes para a variável dict_list_discents\n",
    "filename_discents = 'discents_dict_list.json'\n",
    "dict_list_discents, formatted_creation_date_discents, formatted_modification_date_discents, time_count, unit = jfm.load_from_json(os.path.join(folder_data_input,filename_discents))\n",
    "\n",
    "print(f\"\\n{len(dict_list_discents)} currículos carregados na lista de dicionários de discentes '{filename_discents}'\")\n",
    "print(f\"Arquivo criado inicialmente em {formatted_creation_date_discents} carregado com sucesso\")\n",
    "print(f\"Extração realizada em {formatted_modification_date_discents} a {time_count} {unit}\")\n",
    "print('\\nExemplo dos dados das publicações de discentes:')\n",
    "pprint([x.get('Produções') for x in dict_list_discents][1].get('Artigos completos publicados em periódicos')[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ac7a804",
   "metadata": {},
   "source": [
    "### Atualizar dados dos Qualis Periódicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d8747fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# stratifier = GetQualis()\n",
    "\n",
    "# print('\\nAdicionar Qualis Periódicos a publicações dos docentes...')\n",
    "# pathfilename = os.path.join(folder_data_input,'docents_dict_list.json')\n",
    "# json_data_discents = stratifier.buscar_qualis_e_atualizar_arquivo(dict_list_docents, pathfilename)\n",
    "\n",
    "# print('\\nAdicionar Qualis Periódicos a publicações dos discentes...')\n",
    "# pathfilename = os.path.join(folder_data_input,'discents_dict_list.json')\n",
    "# json_data_discents = stratifier.buscar_qualis_e_atualizar_arquivo(dict_list_discents, pathfilename)\n",
    "\n",
    "# print('\\nExemplo atualizado dos dados das publicações de docentes:')\n",
    "# # Verificar se o dado Qualis está presente no arquivo de dados de docentes\n",
    "# pprint([x.get('Produções') for x in dict_list_docents][-1].get('Artigos completos publicados em periódicos')[0])\n",
    "\n",
    "# print('\\nExemplo atualizado dos dados das publicações de discentes:')\n",
    "# # Verificar se o dado Qualis está presente no arquivo de dados de discentes\n",
    "# pprint([x.get('Produções') for x in dict_list_discents][1].get('Artigos completos publicados em periódicos')[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "433c0e93",
   "metadata": {},
   "source": [
    "## Montar Grafo com NetworkX"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6753e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pip install community\n",
    "# %pip install sentence_transformers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faf7f177",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Teste de criação de link simbólico\n",
    "# import os\n",
    "\n",
    "# try:\n",
    "#     os.symlink(\"arquivo_original.txt\", \"link_simbolico.txt\")\n",
    "#     print(\"Link simbólico criado com sucesso!\")\n",
    "# except OSError as e:\n",
    "#     print(f\"Erro ao criar o link simbólico: {e}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3c66e61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import logging\n",
    "import networkx as nx\n",
    "import community as community_louvain\n",
    "from neo4j import GraphDatabase\n",
    "from sentence_transformers import SentenceTransformer\n",
    "from sklearn.metrics.cluster import adjusted_rand_score\n",
    "# from sklearn.metrics.pairwise import cosine_similarity # apresentou erro de sincronização CUDA\n",
    "from torch.nn.functional import cosine_similarity  # Similaridade do cosseno no PyTorch\n",
    "from transformers import AutoTokenizer, AutoModel\n",
    "\n",
    "# Configurar o logger\n",
    "logging.basicConfig(filename='app_semantic_similarity.log', level=logging.INFO, \n",
    "                    format='%(asctime)s - %(levelname)s - %(message)s')\n",
    "\n",
    "def test_gpu():\n",
    "    \"\"\"\n",
    "    Testa se a GPU está disponível e retorna informações sobre ela.\n",
    "    \"\"\"\n",
    "    if torch.cuda.is_available():\n",
    "        logging.info(\"GPU disponível. Informações:\")\n",
    "        logging.info(torch.cuda.get_device_name(0))\n",
    "        logging.info(f\"Memória total: {torch.cuda.get_device_properties(0).total_memory / 1024**2:.2f} MB\")\n",
    "        return True\n",
    "    else:\n",
    "        logging.warning(\"GPU não disponível.\")\n",
    "        return False\n",
    "\n",
    "def is_gpu_memory_sufficient(model_name):\n",
    "    \"\"\"\n",
    "    Verifica se a memória da GPU é suficiente para o modelo especificado.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        model = SentenceTransformer(model_name)\n",
    "        del model\n",
    "        return True\n",
    "    except RuntimeError as e:\n",
    "        if \"CUDA out of memory\" in str(e):\n",
    "            logging.warning(f\"Memória da GPU insuficiente para o modelo {model_name}.\")\n",
    "            return False\n",
    "        else:\n",
    "            raise\n",
    "\n",
    "def clear_gpu_memory():\n",
    "    \"\"\"\n",
    "    Limpa a memória da GPU.\n",
    "    \"\"\"\n",
    "    torch.cuda.empty_cache()\n",
    "    logging.info(\"Memória da GPU limpa.\")\n",
    "\n",
    "class Neo4jError(Exception):\n",
    "    \"\"\"Exceção personalizada para erros relacionados ao Neo4j.\"\"\"\n",
    "    pass\n",
    "\n",
    "class CommunityDetectionError(Exception):\n",
    "    \"\"\"Exceção personalizada para erros na detecção de comunidades.\"\"\"\n",
    "    pass\n",
    "\n",
    "def get_graph_from_neo4j(uri, user, password, query):\n",
    "    \"\"\"\n",
    "    Conecta ao Neo4j, executa a consulta Cypher e retorna o grafo NetworkX.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "    except Exception as e:\n",
    "        logging.error(f\"Erro ao conectar ao Neo4j: {e}\")\n",
    "        raise ConnectionError(f\"Erro ao conectar ao Neo4j: {e}\")\n",
    "\n",
    "    with driver.session() as session:\n",
    "        try:\n",
    "            result = session.run(query)\n",
    "        except Exception as e:\n",
    "            logging.error(f\"Erro ao executar a consulta Cypher: {e}\")\n",
    "            raise Neo4jError(f\"Erro ao executar a consulta Cypher: {e}\")\n",
    "\n",
    "        G = nx.Graph()\n",
    "        for record in result:\n",
    "            try:\n",
    "                node1 = record['n']\n",
    "                node2 = record['r']\n",
    "\n",
    "                # Adicionar nós ao grafo\n",
    "                G.add_node(node1.id, label=list(node1.labels)[0], name=node1.get('name', ''))\n",
    "                if node2:\n",
    "                    G.add_node(node2.id, label=node2.type)\n",
    "\n",
    "                    # Adicionar aresta ao grafo\n",
    "                    G.add_edge(node1.id, node2.id)\n",
    "            except Exception as e:\n",
    "                logging.error(f\"Erro ao processar os dados do Neo4j: {e}\")\n",
    "                raise ValueError(f\"Erro ao processar os dados do Neo4j: {e}\")\n",
    "\n",
    "    driver.close()\n",
    "    return G\n",
    "\n",
    "def semantic_approximation_and_modularity(graph, label1, label2, threshold_range, model_name='bert-base-uncased'):\n",
    "    \"\"\"\n",
    "    Calcula a aproximação semântica entre dois labels de nós e avalia a modularidade.\n",
    "\n",
    "    Args:\n",
    "        graph: Grafo NetworkX contendo os nós e arestas.\n",
    "        label1: Primeiro label de nó.\n",
    "        label2: Segundo label de nó.\n",
    "        threshold_range: Range de valores de threshold para testar.\n",
    "        model_name: Nome do modelo a ser usado para cálculo de embeedings.\n",
    "\n",
    "    Returns:\n",
    "        Dicionário com resultados para cada threshold, incluindo:\n",
    "            - modularity: Valor de modularidade.\n",
    "            - communities: Dicionário com as comunidades encontradas.\n",
    "            - edges: Lista de arestas adicionadas ao grafo.\n",
    "    \"\"\"\n",
    "\n",
    "    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "    model = AutoModel.from_pretrained(model_name).to(device)\n",
    "\n",
    "    results = {}\n",
    "\n",
    "    # Obter nós com os labels especificados\n",
    "    nodes_label1 = [node for node, data in graph.nodes(data=True) if data.get('label') == label1]\n",
    "    nodes_label2 = [node for node, data in graph.nodes(data=True) if data.get('label') == label2]\n",
    "\n",
    "    if not nodes_label1 or not nodes_label2:\n",
    "        raise ValueError(f\"Labels de nós não encontrados no grafo: {label1}, {label2}\")\n",
    "\n",
    "    for threshold in threshold_range:\n",
    "        edges_to_add = []\n",
    "        for node1 in nodes_label1:\n",
    "            for node2 in nodes_label2:\n",
    "                try:\n",
    "                    text1 = graph.nodes[node1].get('name', '')\n",
    "                    text2 = graph.nodes[node2].get('name', '')\n",
    "\n",
    "                    # Tokenizar e obter embeddings com PyTorch\n",
    "                    inputs1 = tokenizer(text1, return_tensors=\"pt\", padding=True, truncation=True).to(device)\n",
    "                    inputs2 = tokenizer(text2, return_tensors=\"pt\", padding=True, truncation=True).to(device)\n",
    "                    with torch.no_grad():\n",
    "                        outputs1 = model(**inputs1)\n",
    "                        outputs2 = model(**inputs2)\n",
    "                    embedding1 = outputs1.pooler_output.cpu().numpy()  # Converter para numpy\n",
    "                    embedding2 = outputs2.pooler_output.cpu().numpy()  # Converter para numpy\n",
    "\n",
    "                    similarity = cosine_similarity(torch.from_numpy(embedding1), torch.from_numpy(embedding2))[0][0].item()  # Converter para escalar\n",
    "                except Exception as e:\n",
    "                    logging.error(f\"Erro ao calcular a similaridade entre embeddings: {e}\")\n",
    "                    raise\n",
    "\n",
    "                if similarity >= threshold:\n",
    "                    edges_to_add.append((node1, node2))    \n",
    "\n",
    "        # Criar subgrafo com os nós e arestas relevantes\n",
    "        subgraph = graph.subgraph(nodes_label1 + nodes_label2 + ['CompetenciaPesquisa'])\n",
    "        subgraph.add_edges_from(edges_to_add)\n",
    "\n",
    "        # Calcular modularidade\n",
    "        try:\n",
    "            partition = community_louvain.best_partition(subgraph)\n",
    "            modularity = community_louvain.modularity(partition, subgraph)\n",
    "        except Exception as e:\n",
    "            logging.error(f\"Erro ao detectar comunidades: {e}\")\n",
    "            raise CommunityDetectionError(f\"Erro ao detectar comunidades: {e}\")\n",
    "\n",
    "        results[threshold] = {\n",
    "            'modularity': modularity,\n",
    "            'communities': partition,\n",
    "            'edges': edges_to_add\n",
    "        }\n",
    "\n",
    "    return results                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aafd829a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# def semantic_approximation_and_modularity(graph, label1, label2, threshold_range, model_name='paraphrase-distilroberta-base-v2'):\n",
    "#     \"\"\"\n",
    "#     Calcula a aproximação semântica entre dois labels de nós e avalia a modularidade.\n",
    "\n",
    "#     Args:\n",
    "#         graph: Grafo NetworkX contendo os nós e arestas.\n",
    "#         label1: Primeiro label de nó.\n",
    "#         label2: Segundo label de nó.\n",
    "#         threshold_range: Range de valores de threshold para testar.\n",
    "#         model_name: Nome do modelo SentenceTransformer a ser usado (opcional).\n",
    "\n",
    "#     Returns:\n",
    "#         Dicionário com resultados para cada threshold, incluindo:\n",
    "#             - modularity: Valor de modularidade.\n",
    "#             - communities: Dicionário com as comunidades encontradas.\n",
    "#             - edges: Lista de arestas adicionadas ao grafo.\n",
    "#     \"\"\"\n",
    "\n",
    "#     if test_gpu():\n",
    "#         if not is_gpu_memory_sufficient(model_name):\n",
    "#             model_name = 'all-mpnet-base-v2'  # Modelo menor\n",
    "#             logging.info(f\"Usando modelo menor: {model_name}\")\n",
    "#     else:\n",
    "#         logging.info(\"Usando CPU.\")\n",
    "\n",
    "#     clear_gpu_memory()  # Limpar a memória da GPU antes de usar o modelo\n",
    "\n",
    "#     try:\n",
    "#         # Tentar usar a GPU primeiro\n",
    "#         model = SentenceTransformer(model_name)\n",
    "#     except RuntimeError as e:\n",
    "#         if \"CUDA\" in str(e):\n",
    "#             logging.warning(f\"Erro de CUDA: {e}. Forçando o uso da CPU...\")\n",
    "#             # Forçar o uso da CPU\n",
    "#             model = SentenceTransformer(model_name, device='cpu')\n",
    "#         else:\n",
    "#             raise  # Re-lançar a exceção se não for um erro CUDA\n",
    "\n",
    "#     results = {}\n",
    "\n",
    "#     # Obter nós com os labels especificados\n",
    "#     nodes_label1 = [node for node, data in graph.nodes(data=True) if data.get('label') == label1]\n",
    "#     nodes_label2 = [node for node, data in graph.nodes(data=True) if data.get('label') == label2]\n",
    "\n",
    "#     if not nodes_label1 or not nodes_label2:\n",
    "#         raise ValueError(f\"Labels de nós não encontrados no grafo: {label1}, {label2}\")\n",
    "\n",
    "#     for threshold in threshold_range:\n",
    "#         edges_to_add = []\n",
    "#         for node1 in nodes_label1:\n",
    "#             for node2 in nodes_label2:\n",
    "#                 try:\n",
    "#                     text1 = graph.nodes[node1].get('name', '')\n",
    "#                     text2 = graph.nodes[node2].get('name', '')\n",
    "#                     embedding1 = model.encode(text1).reshape(1, -1)\n",
    "#                     embedding2 = model.encode(text2).reshape(1, -1)\n",
    "#                     similarity = cosine_similarity(embedding1, embedding2)[0][0]\n",
    "#                 except Exception as e:\n",
    "#                     logging.error(f\"Erro ao calcular a similaridade entre embeddings: {e}\")\n",
    "#                     raise\n",
    "\n",
    "#                 if similarity >= threshold:\n",
    "#                     edges_to_add.append((node1, node2))\n",
    "\n",
    "#         # Criar subgrafo com os nós e arestas relevantes\n",
    "#         subgraph = graph.subgraph(nodes_label1 + nodes_label2 + ['CompetenciaPesquisa'])\n",
    "#         subgraph.add_edges_from(edges_to_add)\n",
    "\n",
    "#         # Calcular modularidade\n",
    "#         try:\n",
    "#             partition = community_louvain.best_partition(subgraph)\n",
    "#             modularity = community_louvain.modularity(partition, subgraph)\n",
    "#         except Exception as e:\n",
    "#             logging.error(f\"Erro ao detectar comunidades: {e}\")\n",
    "#             raise CommunityDetectionError(f\"Erro ao detectar comunidades: {e}\")\n",
    "\n",
    "#         results[threshold] = {\n",
    "#             'modularity': modularity,\n",
    "#             'communities': partition,\n",
    "#             'edges': edges_to_add\n",
    "#         }\n",
    "\n",
    "#     return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25dfb14f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exemplo de uso\n",
    "uri = \"bolt://localhost:7687\"\n",
    "user = \"neo4j\"\n",
    "password = \"password\"\n",
    "\n",
    "query = \"\"\"\n",
    "MATCH (n)\n",
    "WHERE NOT n:Revista OR EXISTS(()-[:PUBLICADO_EM]->(n))\n",
    "OPTIONAL MATCH (n)-[r]-() \n",
    "RETURN n, r\n",
    "\"\"\"\n",
    "\n",
    "G = get_graph_from_neo4j(uri, user, password, query)\n",
    "results = semantic_approximation_and_modularity(G, 'AreaAvaliacao', 'GrandeArea', [0.5, 0.6, 0.7, 0.8])\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19c6417b",
   "metadata": {},
   "outputs": [],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec67ce0",
   "metadata": {},
   "source": [
    "# <b>F07: Montar grafo/análise de redes</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e29eb5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "uri = \"bolt://localhost:7687\"\n",
    "user = \"neo4j\"\n",
    "password = \"password\"\n",
    "persister = Neo4jPersister(uri, user, password)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2243df4d",
   "metadata": {},
   "source": [
    "### Persistir dados de revistas (14min 31.625 periódicos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "350ccb9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Persiste dados da lista Sucupira no Neo4j dados de > 31.000 revistas\n",
    "# t1 = time.time()\n",
    "# persister.persistir_revistas_da_planilha()\n",
    "# print(f'\\n{preparer.tempo(t1,time.time())} para persistir dados de todas 31.625 revistas da Plataforma Sucupira')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b89197",
   "metadata": {},
   "source": [
    "### Persistir dados dos docentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47feea72",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_docent_nodes(dict_list_docents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21b121f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_areas_nodes(dict_list_docents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8bc3190",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_producoes_pesquisador(dict_list_docents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe7fe94b",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_pesquisador_grande_area_relationships(dict_list_docents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39f2dc5a",
   "metadata": {},
   "source": [
    "### Persistir dados de discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "849d2526",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_discent_nodes(dict_list_discents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2adf899",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_producoes_pesquisador(dict_list_discents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6355bd46",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_areas_nodes(dict_list_discents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de886282",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.persist_pesquisador_grande_area_relationships(dict_list_discents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c00eb003",
   "metadata": {},
   "source": [
    "### Persistir dados de orientações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5fefdd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = time.time()\n",
    "preparer = EnvironmentSetup()\n",
    "persister.persist_advices_relationships(dict_list_docents)\n",
    "print(f'\\n{preparer.tempo(t1,time.time())} para persistir dados de todas orientações nos dados de docentes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af3f28f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [x.keys() for x in dict_list_docents]\n",
    "[x.get('Produções') for x in dict_list_docents][1].get('Artigos completos publicados em periódicos')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14621d0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x.get('Orientações') for x in dict_list_docents][4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60164ff8",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x.get('Orientações') for x in dict_list_discents][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3b056f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'\\n{preparer.tempo(t00,time.time())} para recuperar, processar e persistir dados.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "005b615a",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cbd0a4ba",
   "metadata": {},
   "source": [
    "# <b>F08: Visualizar grafos e análises geradas</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9431b77d",
   "metadata": {},
   "outputs": [],
   "source": [
    "uri = \"bolt://localhost:7687\"\n",
    "user = \"neo4j\"\n",
    "password = \"password\"\n",
    "persister = Neo4jPersister(uri, user, password)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa17ed4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "persister.desenhar_grafo_revistas_capes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a2a82e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pip install groq\n",
    "# %pip install langchain-groq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5f46865",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e5fc82d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "882cd6f7",
   "metadata": {},
   "source": [
    "# Interação via LLM Llama3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "419bb124",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from groq import Groq\n",
    "\n",
    "keys,_,_,_,_ = jfm.load_from_json(os.path.join('../../../','secrets.json'))\n",
    "client = Groq(\n",
    "    api_key=keys.get('groq'),\n",
    ")\n",
    "\n",
    "chat_completion = client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\n",
    "            \"role\": \"user\",\n",
    "            \"content\": \"Explain the importance of fast language models\",\n",
    "        }\n",
    "    ],\n",
    "    # model=\"llama3-8b-8192\",\n",
    "    model = 'llama3-70b-8192',\n",
    ")\n",
    "\n",
    "print(chat_completion.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "001df8a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from groq import Groq\n",
    "\n",
    "keys,_,_,_,_ = jfm.load_from_json(os.path.join('../../../','secrets.json'))\n",
    "client = Groq(\n",
    "    api_key=keys.get('groq'),\n",
    ")\n",
    "\n",
    "chat_completion = client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\n",
    "            \"role\": \"user\",\n",
    "            \"content\": \"Gerenate a anime history about StarWars, and present the response in Brazilian Portuguese\",\n",
    "        }\n",
    "    ],\n",
    "    # model=\"llama3-8b-8192\",\n",
    "    model = 'llama3-70b-8192',\n",
    ")\n",
    "\n",
    "print(chat_completion.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0b170f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from groq import Groq\n",
    "\n",
    "keys,_,_,_,_ = jfm.load_from_json(os.path.join('../../../','secrets.json'))\n",
    "client = Groq(\n",
    "    api_key=keys.get('groq'),\n",
    ")\n",
    "\n",
    "chat_completion = client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\n",
    "            \"role\": \"user\",\n",
    "            \"content\": \"Explain the importance of fast language models\",\n",
    "        }\n",
    "    ],\n",
    "    # model=\"llama3-8b-8192\",\n",
    "    model = 'llama3-70b-8192',\n",
    ")\n",
    "\n",
    "print(chat_completion.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "464b579a",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Cypher from Natural Language\n",
    "from typing import List, Optional\n",
    "import json\n",
    "\n",
    "from pydantic import BaseModel\n",
    "from groq import Groq\n",
    "\n",
    "groq = Groq(\n",
    "    api_key=keys.get('groq'),\n",
    ")\n",
    "\n",
    "# Data model for LLM to generate\n",
    "class Ingredient(BaseModel):\n",
    "    name: str\n",
    "    quantity: str\n",
    "    quantity_unit: Optional[str]\n",
    "\n",
    "\n",
    "class Recipe(BaseModel):\n",
    "    recipe_name: str\n",
    "    ingredients: List[Ingredient]\n",
    "    directions: List[str]\n",
    "\n",
    "\n",
    "def get_recipe(recipe_name: str) -> Recipe:\n",
    "    chat_completion = groq.chat.completions.create(\n",
    "        messages=[\n",
    "            {\n",
    "                \"role\": \"system\",\n",
    "                \"content\": \"You are a recipe database that outputs recipes in JSON.\\n\"\n",
    "                # Pass the json schema to the model. Pretty printing improves results.\n",
    "                f\" The JSON object must use the schema: {json.dumps(Recipe.model_json_schema(), indent=2)}\",\n",
    "            },\n",
    "            {\n",
    "                \"role\": \"user\",\n",
    "                \"content\": f\"Fetch a recipe for {recipe_name}\",\n",
    "            },\n",
    "        ],\n",
    "        model=\"llama3-8b-8192\",\n",
    "        temperature=0,\n",
    "        # Streaming is not supported in JSON mode\n",
    "        stream=False,\n",
    "        # Enable JSON mode setting the response format\n",
    "        response_format={\"type\": \"json_object\"},\n",
    "    )\n",
    "    return Recipe.model_validate_json(chat_completion.choices[0].message.content)\n",
    "\n",
    "\n",
    "def print_recipe(recipe: Recipe):\n",
    "    print(\"Recipe:\", recipe.recipe_name)\n",
    "\n",
    "    print(\"\\nIngredients:\")\n",
    "    for ingredient in recipe.ingredients:\n",
    "        print(\n",
    "            f\"- {ingredient.name}: {ingredient.quantity} {ingredient.quantity_unit or ''}\"\n",
    "        )\n",
    "    print(\"\\nDirections:\")\n",
    "    for step, direction in enumerate(recipe.directions, start=1):\n",
    "        print(f\"{step}. {direction}\")\n",
    "\n",
    "\n",
    "recipe = get_recipe(\"apple pie\")\n",
    "print_recipe(recipe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4db57dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from groq import Groq\n",
    "import os\n",
    "import json\n",
    "\n",
    "client = Groq(api_key = keys.get('groq'))\n",
    "MODEL = 'llama3-70b-8192'\n",
    "\n",
    "\n",
    "# Example dummy function hard coded to return the score of an NBA game\n",
    "def get_game_score(team_name):\n",
    "    \"\"\"Get the current score for a given NBA game\"\"\"\n",
    "    if \"warriors\" in team_name.lower():\n",
    "        return json.dumps({\"game_id\": \"401585601\", \"status\": 'Final', \"home_team\": \"Los Angeles Lakers\", \"home_team_score\": 121, \"away_team\": \"Golden State Warriors\", \"away_team_score\": 128})\n",
    "    elif \"lakers\" in team_name.lower():\n",
    "        return json.dumps({\"game_id\": \"401585601\", \"status\": 'Final', \"home_team\": \"Los Angeles Lakers\", \"home_team_score\": 121, \"away_team\": \"Golden State Warriors\", \"away_team_score\": 128})\n",
    "    elif \"nuggets\" in team_name.lower():\n",
    "        return json.dumps({\"game_id\": \"401585577\", \"status\": 'Final', \"home_team\": \"Miami Heat\", \"home_team_score\": 88, \"away_team\": \"Denver Nuggets\", \"away_team_score\": 100})\n",
    "    elif \"heat\" in team_name.lower():\n",
    "        return json.dumps({\"game_id\": \"401585577\", \"status\": 'Final', \"home_team\": \"Miami Heat\", \"home_team_score\": 88, \"away_team\": \"Denver Nuggets\", \"away_team_score\": 100})\n",
    "    else:\n",
    "        return json.dumps({\"team_name\": team_name, \"score\": \"unknown\"})\n",
    "\n",
    "def run_conversation(user_prompt):\n",
    "    # Step 1: send the conversation and available functions to the model\n",
    "    messages=[\n",
    "        {\n",
    "            \"role\": \"system\",\n",
    "            \"content\": \"You are a function calling LLM that uses the data extracted from the get_game_score function to answer questions around NBA game scores. Include the team and their opponent in your response.\"\n",
    "        },\n",
    "        {\n",
    "            \"role\": \"user\",\n",
    "            \"content\": user_prompt,\n",
    "        }\n",
    "    ]\n",
    "    tools = [\n",
    "        {\n",
    "            \"type\": \"function\",\n",
    "            \"function\": {\n",
    "                \"name\": \"get_game_score\",\n",
    "                \"description\": \"Get the score for a given NBA game\",\n",
    "                \"parameters\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"team_name\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"The name of the NBA team (e.g. 'Golden State Warriors')\",\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\"team_name\"],\n",
    "                },\n",
    "            },\n",
    "        }\n",
    "    ]\n",
    "    response = client.chat.completions.create(\n",
    "        model=MODEL,\n",
    "        messages=messages,\n",
    "        tools=tools,\n",
    "        tool_choice=\"auto\",\n",
    "        max_tokens=4096\n",
    "    )\n",
    "\n",
    "    response_message = response.choices[0].message\n",
    "    tool_calls = response_message.tool_calls\n",
    "    # Step 2: check if the model wanted to call a function\n",
    "    if tool_calls:\n",
    "        # Step 3: call the function\n",
    "        # Note: the JSON response may not always be valid; be sure to handle errors\n",
    "        available_functions = {\n",
    "            \"get_game_score\": get_game_score,\n",
    "        }  # only one function in this example, but you can have multiple\n",
    "        messages.append(response_message)  # extend conversation with assistant's reply\n",
    "        # Step 4: send the info for each function call and function response to the model\n",
    "        for tool_call in tool_calls:\n",
    "            function_name = tool_call.function.name\n",
    "            function_to_call = available_functions[function_name]\n",
    "            function_args = json.loads(tool_call.function.arguments)\n",
    "            function_response = function_to_call(\n",
    "                team_name=function_args.get(\"team_name\")\n",
    "            )\n",
    "            messages.append(\n",
    "                {\n",
    "                    \"tool_call_id\": tool_call.id,\n",
    "                    \"role\": \"tool\",\n",
    "                    \"name\": function_name,\n",
    "                    \"content\": function_response,\n",
    "                }\n",
    "            )  # extend conversation with function response\n",
    "        second_response = client.chat.completions.create(\n",
    "            model=MODEL,\n",
    "            messages=messages\n",
    "        )  # get a new response from the model where it can see the function response\n",
    "        return second_response.choices[0].message.content\n",
    "\n",
    "user_prompt = \"What was the score of the Warriors game?\"\n",
    "print(run_conversation(user_prompt))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21be0009",
   "metadata": {},
   "source": [
    "# Outros testes e experimentos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2a77e00",
   "metadata": {},
   "outputs": [],
   "source": [
    "def avaliar_tipo_instancias_arvore(estrutura, nivel=1, identacao=\"\"):\n",
    "    \"\"\"\n",
    "    Função recursiva que avalia o tipo e a quantidade de instâncias em cada nível da estrutura, exibindo-a em formato de árvore.\n",
    "\n",
    "    Args:\n",
    "        estrutura (list|dict): A estrutura a ser avaliada.\n",
    "        nivel (int): Nível atual da recurssão (inicia em 1).\n",
    "        identacao (str): String de indentação para cada nível (inicia vazia).\n",
    "\n",
    "    Returns:\n",
    "        None: A função imprime os resultados na tela e não retorna nada.\n",
    "    \"\"\"\n",
    "\n",
    "    if isinstance(estrutura, list):\n",
    "        print(f\"{identacao}N{nivel}. Lista: {len(estrutura)} elementos\")\n",
    "        for item in estrutura:\n",
    "            avaliar_tipo_instancias_arvore(item, nivel + 1, identacao + \"    \")\n",
    "\n",
    "    elif isinstance(estrutura, dict):\n",
    "        print(f\"{identacao}N{nivel}. Mapa: {estrutura.keys()}\")\n",
    "        for chave, valor in estrutura.items():\n",
    "            print(f\"{identacao}  {chave}:\")\n",
    "            avaliar_tipo_instancias_arvore(valor, nivel + 1, identacao + \"    \")\n",
    "\n",
    "    elif isinstance(estrutura, str):\n",
    "        print(f\"{identacao}N{nivel}. String: {estrutura}\")\n",
    "\n",
    "for dict_pesq in dict_list_docents[:3]:\n",
    "    avaliar_tipo_instancias_arvore(dict_pesq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fccc6c54",
   "metadata": {},
   "outputs": [],
   "source": [
    "for dict_pesq in dict_list_docents:\n",
    "    if isinstance(dict_pesq, list):\n",
    "        print(f'L1. Lista: {dict_pesq}')\n",
    "    elif isinstance(dict_pesq, dict):\n",
    "        print(f'L1. Mapa: {dict_pesq.keys()}')\n",
    "        for tipo in dict_pesq.values():\n",
    "            if isinstance(tipo, list):\n",
    "                print(f'    L2. Lista: {tipo}')\n",
    "            elif isinstance(tipo, dict):\n",
    "                print(f'    L2. Mapa: {tipo}')\n",
    "                for subtipo in tipo.values():\n",
    "                    if isinstance(subtipo, list):\n",
    "                        print(f'        L3. Lista: {len(subtipo)} elementos')\n",
    "                        for subsubtipo in subtipo:\n",
    "                            if isinstance(subsubtipo, list):\n",
    "                                print(f'            L4. Lista: {subsubtipo}')\n",
    "                            elif isinstance(subsubtipo, dict):\n",
    "                                print(f'            L4. Mapa: {subsubtipo.keys()}')\n",
    "                                for subsubsubtipo in subsubtipo.values():\n",
    "                                    if isinstance(subsubsubtipo, list):\n",
    "                                        print(f'                L5. Lista: {subsubsubtipo}')\n",
    "                                    elif isinstance(subsubsubtipo, dict):\n",
    "                                        print(f'                L5. Mapa: {subsubsubtipo.keys()}')\n",
    "                                    elif isinstance(subsubsubtipo, str):\n",
    "                                        print(f'                L5. String: {subsubsubtipo}')                                  \n",
    "                            elif isinstance(subsubtipo, str):\n",
    "                                print(f'            L4. String: {subsubtipo}')     \n",
    "                    elif isinstance(subtipo, dict):\n",
    "                        print(f'        L3. Mapa: {subtipo.keys()}')\n",
    "                        for subsubtipo in subtipo.values():\n",
    "                            if isinstance(subsubtipo, list):\n",
    "                                print(f'            L4. Lista: {subsubtipo}')\n",
    "                            elif isinstance(subsubtipo, dict):\n",
    "                                print(f'            L4. Mapa: {subsubtipo.keys()}')\n",
    "                            elif isinstance(subsubtipo, str):\n",
    "                                print(f'            L4. String: {subsubtipo}')                             \n",
    "                    elif isinstance(tipo, str):\n",
    "                        print(f'        L3. String: {subtipo}')                \n",
    "            elif isinstance(tipo, str):\n",
    "                print(f'    L2. String: {tipo}')\n",
    "    elif isinstance(dict_pesq, str):\n",
    "        print(f'L1. String: {dict_pesq}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea0a81a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_list[20:21]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "991a5d7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[20].get('Identificação').items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c6f6d0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[5].get('Idiomas'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9e49f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(x.get('Descrição') for x in dict_list[5].get('Linhas de Pesquisa'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7213c33b",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[5].get('Áreas').values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0886075d",
   "metadata": {},
   "outputs": [],
   "source": [
    "tipos=[]\n",
    "for pesq in dict_list:\n",
    "    for t, s in pesq.get('Produções').items():\n",
    "        if t not in tipos:\n",
    "            tipos.append(t)\n",
    "            print(t, type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46fe6f3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[1].get('Produções').get('Artigos completos publicados em periódicos')[0].keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bb7c6e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[5].get('Atuação Profissional'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19d8a20d",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(dict_list[5].get('Formação').items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "331e1f72",
   "metadata": {},
   "source": [
    "## Classe para gerar dados para grafos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a973a151",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from neo4j import GraphDatabase\n",
    "# import json\n",
    "\n",
    "# class Neo4jConnection:\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def persist_data(self, data):\n",
    "#         with self._driver.session() as session:\n",
    "#             for person_data in data:\n",
    "#                 person_id = person_data['Identificação']['ID Lattes']\n",
    "#                 prepared_data, relationships = self._prepare_data(person_data, person_id)\n",
    "#                 session.write_transaction(self._create_person_node, person_id, prepared_data)\n",
    "#                 self._create_relationships(session, person_id, relationships)\n",
    "\n",
    "#     @staticmethod\n",
    "#     def _create_person_node(tx, person_id, person_data):\n",
    "#         tx.run(\n",
    "#             \"MERGE (p:Person {id_lattes: $person_id}) \"\n",
    "#             \"SET p += $person_data\",\n",
    "#             person_id=person_id,\n",
    "#             person_data=person_data\n",
    "#         )\n",
    "\n",
    "#     def _prepare_data(self, data, person_id):\n",
    "#         prepared_data = {}\n",
    "#         relationships = []\n",
    "#         for key, value in data.items():\n",
    "#             if isinstance(value, dict):\n",
    "#                 label = key.capitalize().replace(' ', '_')\n",
    "#                 prepared_data.update({f'{label}_{k}': v for k, v in value.items()})\n",
    "#                 sub_prepared_data, sub_relationships = self._prepare_data(value, person_id)\n",
    "#                 prepared_data.update(sub_prepared_data)\n",
    "#                 relationships.extend(sub_relationships)\n",
    "#                 relationships.append((label, {'label': 'Person', 'person_id': person_id}))\n",
    "#             elif isinstance(value, list):\n",
    "#                 for idx, item in enumerate(value):\n",
    "#                     if isinstance(item, dict):\n",
    "#                         nested_label = f'{key}_{idx}'\n",
    "#                         nested_prepared_data, nested_relationships = self._prepare_data(item, person_id)\n",
    "#                         prepared_data.update({f'{nested_label}_{k}': v for k, v in item.items()})\n",
    "#                         prepared_data.update(nested_prepared_data)\n",
    "#                         relationships.extend(nested_relationships)\n",
    "#                         relationships.append((nested_label, {'label': key.capitalize().replace(' ', '_'), 'person_id': person_id}))\n",
    "#                     elif isinstance(item, str):\n",
    "#                         # Tratar strings\n",
    "#                         if \":\" in item:\n",
    "#                             label, value = item.split(\":\", 1)\n",
    "#                             prepared_data[f'{key}_{idx}'] = value.strip()\n",
    "#                             relationships.append((label.strip(), {'label': key.capitalize().replace(' ', '_'), 'person_id': person_id}))\n",
    "#                         else:\n",
    "#                             prepared_data[f'{key}_{idx}'] = item.strip()\n",
    "#         return prepared_data, relationships\n",
    "\n",
    "#     def _create_relationships(self, session, person_id, relationships):\n",
    "#         for label, parent_id in relationships:\n",
    "#             query = (\n",
    "#                 f\"MATCH (p:Person {{id_lattes: '{person_id}'}}) \"\n",
    "#                 f\"MATCH (n:{label} {{id_lattes: '{person_id}_{label}'}}) \"\n",
    "#                 f\"MERGE (p)-[:HAS_{label}]->(n)\"\n",
    "#             )\n",
    "#             if parent_id:\n",
    "#                 query += (\n",
    "#                     f\" MERGE (parent:{parent_id['label']} {{id_lattes: '{parent_id['person_id']}'}}) \"\n",
    "#                     f\"MERGE (parent)-[:HAS_{label}]->(n)\"\n",
    "#                 )\n",
    "#             session.run(query)\n",
    "\n",
    "# # Dados de conexão com o banco de dados Neo4j\n",
    "# uri = \"bolt://localhost:7687\"\n",
    "# user = \"neo4j\"\n",
    "# password = \"password\"\n",
    "\n",
    "# # Conecta-se ao banco de dados Neo4j e persiste os dados\n",
    "# connection = Neo4jConnection(uri, user, password)\n",
    "# connection.persist_data(dict_list)\n",
    "# connection.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85580969",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "183b53cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from datetime import datetime\n",
    "# from neo4j import GraphDatabase\n",
    "# import ast\n",
    "\n",
    "# class GraphPreparer:\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._uri = uri\n",
    "#         self._user = user\n",
    "#         self._password = password\n",
    "#         self._driver = None\n",
    "\n",
    "#     def connect(self):\n",
    "#         self._driver = GraphDatabase.driver(self._uri, auth=(self._user, self._password))\n",
    "\n",
    "#     def prepare_data_from_file(self, file_path):\n",
    "#         nodes = []\n",
    "#         relationships = []\n",
    "\n",
    "#         with open(file_path, 'r', encoding='utf-8') as file:\n",
    "#             data = json.load(file)\n",
    "\n",
    "#         for person_data in data:\n",
    "#             print(person_data.keys())\n",
    "#             person_id = person_data['Identificação'].get('ID Lattes')\n",
    "#             nodes.append(('Pesquisador', {'id_lattes': person_id}))\n",
    "            \n",
    "#             for language in person_data.get('Idiomas', []):\n",
    "#                 language_name = language['Idioma']\n",
    "#                 proficiency = language['Proficiência']\n",
    "#                 nodes.append(('Idioma', {'nome_idioma': language_name, 'proficiencia': proficiency}))\n",
    "#                 relationships.append(('Pesquisador', {'id_lattes': person_id}, 'FALA', {'nome_idioma': language_name}))\n",
    "            \n",
    "#             for academic_info in person_data.get('Formação', {}).get('Acadêmica', []):\n",
    "#                 description = academic_info['Descrição']\n",
    "#                 nodes.append(('Curso', {'descricao': description}))\n",
    "#                 relationships.append(('Pesquisador', {'id_lattes': person_id}, 'REALIZOU', {'descricao': description}))\n",
    "                \n",
    "#             for professional_info in person_data.get('Atuação Profissional', []):\n",
    "#                 institution = professional_info['Instituição']\n",
    "#                 description = professional_info['Descrição']\n",
    "#                 relationships.append(('Pesquisador', {'id_lattes': person_id}, 'ATUA', {'instituicao': institution, 'descricao': description}))\n",
    "\n",
    "#         return nodes, relationships\n",
    "\n",
    "#     def persist_data(self, data_for_neo4j):\n",
    "#         try:\n",
    "#             with self._driver.session() as session:\n",
    "#                 for data in data_for_neo4j:\n",
    "#                     if data[0] == 'Node':\n",
    "#                         label, properties = data[1:]\n",
    "#                         session.write_transaction(self._create_node, label, **properties)\n",
    "#                     elif data[0] == 'Relationship':\n",
    "#                         start_label, rel_type, end_label = data[1:]\n",
    "#                         session.write_transaction(self._create_relationship, start_label, rel_type, end_label)\n",
    "#         except Exception as e:\n",
    "#             print(f\"Error persisting data: {e}\")\n",
    "\n",
    "#     @staticmethod\n",
    "#     def _create_node(tx, label, **properties):\n",
    "#         query = f\"CREATE (n:{label} $props)\"\n",
    "#         tx.run(query, props=properties)\n",
    "\n",
    "#     @staticmethod\n",
    "#     def _create_relationship(tx, start_label, rel_type, end_label):\n",
    "#         query = \"MATCH (a:{start_label}), (b:{end_label}) \" \\\n",
    "#                 \"CREATE (a)-[r:{rel_type}]->(b)\"\n",
    "#         tx.run(query, start_label=start_label, rel_type=rel_type, end_label=end_label)\n",
    "\n",
    "#     def close(self):\n",
    "#         if self._driver is not None:\n",
    "#             self._driver.close()\n",
    "\n",
    "# # Exemplo de utilização:\n",
    "# graph_preparer = GraphPreparer(uri=\"bolt://localhost:7687\", user=\"neo4j\", password=\"password\")\n",
    "# graph_preparer.connect()\n",
    "\n",
    "# filepath = os.path.join(folder_data_input,'dict_list.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca32e8de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_list[0]['Idioma']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ecf0ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# filepath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15ebece7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nodes, relationships = graph_preparer.prepare_data_from_file(filepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78acb05c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data_for_neo4j = nodes + relationships\n",
    "# graph_preparer.persist_data(data_for_neo4j)\n",
    "\n",
    "# graph_preparer.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1823211",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from neo4j import GraphDatabase\n",
    "# from datetime import datetime\n",
    "\n",
    "# uri = \"bolt://localhost:7687\"\n",
    "# user = \"neo4j\"\n",
    "# password = \"password\"\n",
    "# graph_preparer = GraphPreparer(uri, user, password) # Instanciar classe GraphPreparer\n",
    "# graph_preparer.connect() # Conectar ao banco de dados Neo4j\n",
    "# graph_preparer.process_data(dict_list) # Processar e persistir dados\n",
    "\n",
    "# # Transformar os dados para o formato adequado do Neo4j\n",
    "# dados_para_neo4j = graph_preparer.transform_data_for_neo4j(dict_list)\n",
    "# graph_preparer.persist_nodes_and_relationships(dados_para_neo4j) # PersistiR nós e relações no Neo4j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e803731",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d52fd544",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dados_para_neo4j[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "def42ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from neo4j import GraphDatabase\n",
    "# # Agora você pode inserir os dados no Neo4j utilizando sua biblioteca de acesso ao banco de dados Neo4j, por exemplo:\n",
    "# neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"password\"))\n",
    "# with neo4j_driver.session() as session:\n",
    "#     for item in data_for_neo4j:\n",
    "#         label, properties = item\n",
    "#         cypher_query = f\"CREATE (:{label} $properties)\"\n",
    "#         session.run(cypher_query, properties=properties)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fc9672b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Função para criar nós e relações\n",
    "# def create_nodes_and_relationships(tx, nodes_and_relationships):\n",
    "#     for item in nodes_and_relationships:\n",
    "#         if len(item) == 3:  # Se for uma relação\n",
    "#             origin_node, rel_type, dest_node = item\n",
    "#             tx.run(\n",
    "#                 f\"MATCH (a), (b) WHERE a.name = $origin_node AND b.name = $dest_node \"\n",
    "#                 \"CREATE (a)-[r:\" + rel_type + \"]->(b)\",\n",
    "#                 origin_node=origin_node, dest_node=dest_node\n",
    "#             )\n",
    "\n",
    "# # Conectando ao banco de dados Neo4j e executando a transação\n",
    "# with GraphDatabase.driver(uri, auth=(user, password)) as driver:\n",
    "#     with driver.session() as session:\n",
    "#         session.write_transaction(create_nodes_and_relationships, relacoes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36ed9787",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import json\n",
    "\n",
    "# class Neo4jGraphGenerator:\n",
    "#     def __init__(self, dict_list):\n",
    "#         self.dict_list = dict_list\n",
    "#         self.graph_data = {'nodes': [], 'relationships': []}\n",
    "\n",
    "#     def generate_graph_json(self):\n",
    "#         for item in self.dict_list:\n",
    "#             id_lattes = item.get('Identificação', {}).get('ID Lattes')\n",
    "#             pesquisador = item.get('Identificação', {}).get('Nome')\n",
    "            \n",
    "#             # Adicionar nó de pessoa (Person)\n",
    "#             person_node = {'id': id_lattes, 'label': 'Person', 'name': pesquisador}\n",
    "#             self.graph_data['nodes'].append(person_node)\n",
    "\n",
    "#             areas = item.get('Áreas', {})\n",
    "#             for area in areas.values():\n",
    "#                 # Adicionar nó de Grande Área (GrandeArea)\n",
    "#                 grande_area_node = {'id': area['Grande Área'], 'label': 'GrandeArea', 'description': area['Grande Área']}\n",
    "#                 self.graph_data['nodes'].append(grande_area_node)\n",
    "#                 self.graph_data['relationships'].append({'source': id_lattes, 'target': area['Grande Área'], 'type': 'BELONGS_TO'})\n",
    "                \n",
    "#                 for subarea in area.get('Subáreas', []):\n",
    "#                     # Adicionar nó de Área (Area)\n",
    "#                     area_node = {'id': subarea['Área'], 'label': 'Area', 'description': subarea['Área']}\n",
    "#                     self.graph_data['nodes'].append(area_node)\n",
    "#                     self.graph_data['relationships'].append({'source': area['Grande Área'], 'target': subarea['Área'], 'type': 'BELONGS_TO'})\n",
    "                    \n",
    "#                     # Adicionar nó de Subárea (Subarea)\n",
    "#                     subarea_node = {'id': subarea['Subárea'], 'label': 'Subarea', 'description': subarea['Subárea']}\n",
    "#                     self.graph_data['nodes'].append(subarea_node)\n",
    "#                     self.graph_data['relationships'].append({'source': subarea['Área'], 'target': subarea['Subárea'], 'type': 'BELONGS_TO'})\n",
    "\n",
    "#         return json.dumps(self.graph_data, indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6da358b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generator = Neo4jGraphGenerator(dict_list)\n",
    "# generator.generate_graph_json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b03290d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import json\n",
    "# import re\n",
    "# from neo4j import GraphDatabase\n",
    "\n",
    "# class AreasHandler:\n",
    "\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "        \n",
    "#     def consult_areas_atuacao(self, name):\n",
    "#         with self._driver.session() as session:\n",
    "#             result = session.run(\"MATCH (p:Person {name: $name}) RETURN p.`Áreas de atuação` as areas_atuacao\", name=name)\n",
    "#             record = result.single()\n",
    "#             if record:\n",
    "#                 return record['areas_atuacao']\n",
    "#             return None\n",
    "\n",
    "#     def debug_and_convert(self, areas_str):\n",
    "#         try:\n",
    "#             return json.loads(areas_str)\n",
    "#         except json.JSONDecodeError:\n",
    "#             print(f\"Failed to deserialize JSON string: {areas_str}\")\n",
    "#             return None\n",
    "\n",
    "#     def extract_subarea(self, area_detail):\n",
    "#         # Extract the 'Subárea' content from the area detail\n",
    "#         match = re.search(r'Subárea: ([^/]+)', area_detail)\n",
    "#         if match:\n",
    "#             return match.group(1).strip()\n",
    "#         return None\n",
    "\n",
    "#     def extract_areas(self, area_detail):\n",
    "#         # Extract the 'Grande Área', 'Área', and 'Subárea' contents from the area detail\n",
    "#         grande_area_match = re.search(r'Grande área: ([^/]+)', area_detail)\n",
    "#         area_match = re.search(r'Área: ([^/]+)', area_detail)\n",
    "#         subarea_match = re.search(r'Subárea: ([^/]+)', area_detail)\n",
    "        \n",
    "#         grande_area = grande_area_match.group(1).strip() if grande_area_match else None\n",
    "#         area = area_match.group(1).strip() if area_match else None\n",
    "#         subarea = subarea_match.group(1).strip() if subarea_match else None\n",
    "        \n",
    "#         return grande_area, area, subarea\n",
    "\n",
    "#     def create_areas_relations(self, name):\n",
    "#         # Get 'Áreas de atuação' properties\n",
    "#         areas_properties = self.consult_areas_atuacao(name)\n",
    "\n",
    "#         # Convert the serialized JSON strings back into dictionaries\n",
    "#         try:\n",
    "#             deserialized_areas_properties = self.debug_and_convert(areas_properties)\n",
    "#         except Exception as e:\n",
    "#             print(f\"Error deserializing 'Áreas de atuação' properties: {e}\")\n",
    "#             return\n",
    "\n",
    "#         successful_areas_creations = 0\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             for _, area_detail in deserialized_areas_properties.items():\n",
    "#                 try:\n",
    "#                     # Extracting Grande Área, Área, and Subárea from the details\n",
    "#                     match = re.match(r'Grande área: (.*?) / Área: (.*?) / Subárea: (.*?)(?:/Especialidade: (.*?))?\\.?$', area_detail)\n",
    "#                     if not match:\n",
    "#                         print(f\"Unexpected format for 'Áreas de atuação' detail: {area_detail}\")\n",
    "#                         continue\n",
    "#                     grande_area, area, subarea = match.groups()[:3]\n",
    "\n",
    "#                     # Creating or merging nodes for Subárea, Área, and Grande Área\n",
    "#                     session.run(\"MERGE (s:Subárea {name: $subarea})\", subarea=subarea)\n",
    "#                     session.run(\"MERGE (a:Área {name: $area})\", area=area)\n",
    "#                     session.run(\"MERGE (ga:GrandeÁrea {name: $grande_area})\", grande_area=grande_area)\n",
    "\n",
    "#                     # Creating or merging relationships. Using MERGE ensures no duplicate relationships are created.\n",
    "#                     session.run(\"MATCH (p:Person {name: $name}), (s:Subárea {name: $subarea}) MERGE (p)-[r:ATUA_EM]->(s)\", name=name, subarea=subarea)\n",
    "#                     session.run(\"MATCH (ga:GrandeÁrea {name: $grande_area}), (a:Área {name: $area}) MERGE (ga)-[r:CONTÉM_ÁREA]->(a)\", grande_area=grande_area, area=area)\n",
    "#                     session.run(\"MATCH (a:Área {name: $area}), (s:Subárea {name: $subarea}) MERGE (a)-[r:CONTEM_SUBÁREA]->(s)\", area=area, subarea=subarea)\n",
    "\n",
    "#                     successful_areas_creations += 1\n",
    "#                 except Exception as e:\n",
    "#                     print(f\"Error processing 'Áreas de atuação' detail '{area_detail}': {e}\")\n",
    "\n",
    "#             # Inform the user about areas\n",
    "#             print(f\"{successful_areas_creations} 'Áreas de atuação' relations successfully created.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53fdc77c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# uri = \"bolt://localhost:7687\"\n",
    "# user = \"neo4j\"\n",
    "# password = \"password\"\n",
    "\n",
    "# handleareas = AreasHandler(uri, user, password)\n",
    "# name = 'Antonio Marcos Aires Barbosa'\n",
    "# handleareas.consult_areas_atuacao(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ffefb3c8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5003e41e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from neo4j import GraphDatabase\n",
    "# import urllib.parse\n",
    "# import json\n",
    "# import re\n",
    "\n",
    "# class AdvisorHandler:\n",
    "\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     @staticmethod\n",
    "#     def convert_to_primitives(input_data):\n",
    "#         if input_data is None:\n",
    "#             return None\n",
    "#         if isinstance(input_data, dict):\n",
    "#             for key, value in input_data.items():\n",
    "#                 if isinstance(value, dict):  \n",
    "#                     input_data[key] = json.dumps(AdvisorHandler.convert_to_primitives(value), ensure_ascii=False)\n",
    "#                 else:\n",
    "#                     input_data[key] = AdvisorHandler.convert_to_primitives(value)\n",
    "#             return input_data\n",
    "#         elif isinstance(input_data, list):\n",
    "#             return [AdvisorHandler.convert_to_primitives(item) for item in input_data]\n",
    "#         elif isinstance(input_data, str):\n",
    "#             if 'http://' in input_data or 'https://' in input_data:\n",
    "#                 parts = input_data.split(\" \")\n",
    "#                 new_parts = [urllib.parse.quote(part) if part.startswith(('http://', 'https://')) else part for part in parts]\n",
    "#                 return \" \".join(new_parts)\n",
    "#             return input_data\n",
    "#         elif isinstance(input_data, (int, float, bool)):\n",
    "#             return input_data\n",
    "#         else:\n",
    "#             return str(input_data)\n",
    "\n",
    "#     @staticmethod\n",
    "#     def debug_and_convert(input_data):\n",
    "#         try:\n",
    "#             return AdvisorHandler.convert_to_primitives(input_data)\n",
    "#         except:\n",
    "#             print(\"Conversion failed for:\", input_data)\n",
    "#             raise\n",
    "\n",
    "#     def consult_orientacoes(self, name):\n",
    "#         with self._driver.session() as session:\n",
    "#             query = (\n",
    "#                 \"MATCH (p:Person {name: $name})\"\n",
    "#                 \"RETURN p.Orientações AS orientacoes\"\n",
    "#             )\n",
    "#             result = session.run(query, name=name)\n",
    "#             orient_data = result.single()[\"orientacoes\"]\n",
    "#             if orient_data is None:\n",
    "#                 raise ValueError(f\"No data found for 'Orientações' attribute for Person '{name}'\")\n",
    "#             orient_properties_list = json.loads(orient_data)\n",
    "#             return orient_properties_list\n",
    "\n",
    "#     def create_advisor_relations(self, name):\n",
    "#         # Get Orientações properties\n",
    "#         orient_properties = self.consult_orientacoes(name)\n",
    "\n",
    "#         # Convert the serialized JSON strings back into dictionaries\n",
    "#         try:\n",
    "#             deserialized_orient_properties = self.debug_and_convert(orient_properties)\n",
    "#         except Exception as e:\n",
    "#             print(f\"Error deserializing Orientações properties: {e}\")\n",
    "#             return\n",
    "\n",
    "#         # Advisory relationship mapping\n",
    "#         advisory_types = {\n",
    "#             \"Dissertação de mestrado\": \"ORIENTOU_MESTRADO\",\n",
    "#             \"Tese de doutorado\": \"ORIENTOU_DOUTORADO\",\n",
    "#             \"Trabalho de conclusão de curso de graduação\": \"ORIENTOU_GRADUAÇÃO\"\n",
    "#         }\n",
    "\n",
    "#         successful_advisory_creations = 0\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             for orientacao_category, advisories in deserialized_orient_properties.items():\n",
    "#                 if isinstance(advisories, str):\n",
    "#                     try:\n",
    "#                         advisories = json.loads(advisories)\n",
    "#                     except json.JSONDecodeError:\n",
    "#                         print(f\"Failed to deserialize JSON string in 'Orientações' for category '{orientacao_category}': {advisories}\")\n",
    "#                         continue\n",
    "\n",
    "#                 if not isinstance(advisories, dict):\n",
    "#                     print(f\"Unexpected data type in 'Orientações' for category '{orientacao_category}': {advisories}\")\n",
    "#                     continue\n",
    "\n",
    "#                 for advisory_type, relationships in advisories.items():\n",
    "#                     relation_label = advisory_types.get(advisory_type)\n",
    "#                     if not relation_label:\n",
    "#                         continue  # skip if the advisory type is not one of the specified ones\n",
    "\n",
    "#                     for _, detail in json.loads(relationships).items():\n",
    "#                         try:\n",
    "#                             student_name = detail.split(\".\")[0]\n",
    "#                             title = detail.split(\".\")[1]\n",
    "                            \n",
    "#                             # Extract the year from the detail string\n",
    "#                             year_match = re.search(r'(\\d{4})', detail)\n",
    "#                             year = year_match.group(1) if year_match else None\n",
    "\n",
    "#                             # Create or merge the Orientações node\n",
    "#                             node_query = (\n",
    "#                                 \"MERGE (a:Orientações {Title: $title}) \"\n",
    "#                                 \"ON CREATE SET a.StudentName = $student_name, a.Tipo = $advisory_type, a.Year = $year \"\n",
    "#                                 \"ON MATCH SET a.Tipo = $advisory_type, a.Year = $year \"  # Ensure the 'Tipo' and 'Year' are always updated\n",
    "#                                 \"RETURN a\"\n",
    "#                             )\n",
    "#                             session.run(node_query, title=title, student_name=student_name, advisory_type=advisory_type, year=year)\n",
    "\n",
    "#                             # Create or update the advisory relationship\n",
    "#                             relation_query = (\n",
    "#                                 f\"MATCH (p:Person {{name: $name}}), (a:Orientações {{Title: $title}}) \"\n",
    "#                                 f\"MERGE (p)-[r:{relation_label}]->(a) \"\n",
    "#                             )\n",
    "#                             session.run(relation_query, name=name, title=title)\n",
    "\n",
    "#                             successful_advisory_creations += 1\n",
    "#                         except Exception as e:\n",
    "#                             print(f\"Error processing advisory '{detail}': {e}\")\n",
    "\n",
    "#         # Inform the user about advisories\n",
    "#         print(f\"{successful_advisory_creations} orientações atualizadas com sucesso.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86e3e3bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from neo4j import GraphDatabase\n",
    "\n",
    "# class DataRemovalHandler:\n",
    "\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         \"\"\"\n",
    "#         Inicializa a classe DataRemovalHandler com informações de conexão ao banco de dados Neo4j.\n",
    "\n",
    "#         Parâmetros:\n",
    "#         - uri (str): URI de conexão ao Neo4j.\n",
    "#         - user (str): Nome de usuário para autenticação.\n",
    "#         - password (str): Senha para autenticação.\n",
    "#         \"\"\"\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         \"\"\"\n",
    "#         Fecha a conexão com o banco de dados Neo4j.\n",
    "#         \"\"\"\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def delete_nodes_by_label(self, label):\n",
    "#         \"\"\"\n",
    "#         Deleta todos os nós associados a um label específico no Neo4j.\n",
    "\n",
    "#         Parâmetro:\n",
    "#         - label (str): O label dos nós a serem deletados.\n",
    "\n",
    "#         Retorna:\n",
    "#         - int: O número de nós deletados.\n",
    "#         \"\"\"\n",
    "#         with self._driver.session() as session:\n",
    "#             # Esta consulta combina com todos os nós do label especificado e os deleta\n",
    "#             result = session.run(f\"MATCH (n:{label}) DETACH DELETE n RETURN count(n) as deleted_count\")\n",
    "#             deleted_count = result.single()[\"deleted_count\"]\n",
    "#             return deleted_count"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e663506",
   "metadata": {},
   "source": [
    "## Interação dados do e-Lattes\n",
    "\n",
    "- Fazer análise com lista dos nomes no e-lattes e baixar os arquivos gerados\n",
    "- Salvar na pasta _data/in_zip"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "090dde8d-29f4-4736-b400-beb9627220af",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "## Funções origem para classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0082ebf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip3 install levenshtein\n",
    "# !pip3 install editdistance\n",
    "# !pip3 install seaborn\n",
    "# !pip3 install pyjarowinkler\n",
    "\n",
    "# import os\n",
    "# import re\n",
    "# import csv\n",
    "# import json\n",
    "# import time\n",
    "# import json\n",
    "# import zipfile\n",
    "# import numpy as np\n",
    "# import pandas as pd\n",
    "# import plotly.express as px\n",
    "# import plotly.graph_objects as go\n",
    "# from string import Formatter\n",
    "# from datetime import date, timedelta\n",
    "# from datetime import datetime as dt\n",
    "# from unidecode import unidecode\n",
    "# from plotly.subplots import make_subplots\n",
    "# from pyjarowinkler.distance import get_jaro_distance\n",
    "# from IPython.display import clear_output, display, HTML\n",
    "\n",
    "# pd.set_option('display.max_colwidth', None)\n",
    "# pd.set_option('colheader_justify', 'left')\n",
    "\n",
    "# class PreparadorDePublicacoes:\n",
    "#     def __init__(self):\n",
    "#         self.data = []\n",
    "#         self.colunas = ['idLattes', 'nome', 'tipo', 'titulo_do_capitulo', 'idioma', 'titulo_do_livro', 'ano', 'doi', 'pais_de_publicacao', 'isbn', \n",
    "#         'nome_da_editora', 'numero_da_edicao_revisao', 'organizadores', 'paginas', 'autores', 'autores-endogeno', 'autores-endogeno-nome', 'tags', \n",
    "#         'Hash', 'tipo_producao', 'natureza', 'titulo', 'nome_do_evento', 'ano_do_trabalho', 'pais_do_evento', 'cidade_do_evento', 'classificacao', \n",
    "#         'periodico', 'volume', 'issn', 'estrato_qualis', 'editora', 'numero_de_paginas', 'numero_de_volumes']\n",
    "\n",
    "#     def extrair_dados(self, registro, tipo_producao):\n",
    "#         linha = {coluna: None for coluna in self.colunas}\n",
    "#         linha['tipo_producao'] = tipo_producao  # Define o tipo de produção com base na chave do dicionário\n",
    "        \n",
    "#         # Mapear diretamente os campos do registro para a linha, assegurando que todos os campos desejados sejam extraídos\n",
    "#         for campo in ['titulo', 'idioma', 'periodico', 'ano', 'volume', 'issn', 'estrato_qualis', 'pais_de_publicacao', 'paginas', 'doi']:\n",
    "#             linha[campo] = registro.get(campo, '')\n",
    "\n",
    "#         # Tratar os autores como uma string concatenada se eles existirem\n",
    "#         linha['autores'] = '; '.join(registro.get('autores', []))\n",
    "\n",
    "#         # Tratar os campos 'autores-endogeno' e 'autores-endogeno-nome'\n",
    "#         if 'autores-endogeno' in registro and registro['autores-endogeno']:\n",
    "#             id_endogeno = registro['autores-endogeno'][0]\n",
    "#             linha['idLattes'] = id_endogeno\n",
    "#             linha['nome'] = registro['autores-endogeno-nome'][0].get(id_endogeno, None)\n",
    "        \n",
    "#         # Adicionar os outros campos conforme necessário aqui\n",
    "#         # Por exemplo, tratamento de 'tags', 'Hash', etc., quando necessário\n",
    "\n",
    "#         return linha\n",
    "\n",
    "#     def processar_publicacoes(self):\n",
    "#         linhas = []\n",
    "#         # Itera diretamente sobre cada registro em self.data\n",
    "#         for registro in self.data:\n",
    "#             linha = self.extrair_dados(registro, registro.get('tipo_producao', 'Desconhecido'))\n",
    "#             linhas.append(linha)\n",
    "#         return linhas\n",
    "\n",
    "#     def extract_zips(self, pathzip):\n",
    "#         destination = os.path.join(os.getcwd(), '_data', 'in_json')\n",
    "#         if not os.path.exists(destination):\n",
    "#             os.makedirs(destination)\n",
    "#             print(f\"Criada pasta para armazenar dados descompactados: {destination}\")\n",
    "#         else:\n",
    "#             print(f\"Descompactando arquivos para: {destination}\")\n",
    "\n",
    "#         with zipfile.ZipFile(pathzip, 'r') as zip_ref:\n",
    "#             zip_ref.extractall(destination)\n",
    "        \n",
    "#         print(\"Descompactação concluída...\")\n",
    "#         return destination  # Retorna o caminho onde os arquivos foram descompactados\n",
    "\n",
    "#     def find_and_merge_publication_json_files(self, pathjson):\n",
    "#         all_data = []\n",
    "#         for filename in os.listdir(pathjson):\n",
    "#             if 'publication.json' in filename:\n",
    "#                 print(f\"Extraindo dados do arquivo '{filename}'...\")\n",
    "#                 with open(os.path.join(pathjson, filename), 'r', encoding='utf-8') as file:\n",
    "#                     file_data = json.load(file)\n",
    "#                     for tipo_producao in file_data:  # Para cada tipo de produção no arquivo\n",
    "#                         for ano in file_data[tipo_producao]:  # Para cada ano dentro de um tipo de produção\n",
    "#                             for registro in file_data[tipo_producao][ano]:  # Itera sobre cada registro\n",
    "#                                 # Adicionar ou atualizar o campo 'tipo_producao' em cada registro\n",
    "#                                 registro_atualizado = registro.copy()  # Fazer cópia para evitar modificar o original\n",
    "#                                 registro_atualizado['tipo_producao'] = tipo_producao  # Atualizar ou adicionar o campo 'tipo_producao'\n",
    "#                                 all_data.append(registro_atualizado)  # Adicionar o registro atualizado à lista\n",
    "\n",
    "#         # Salva a lista unificada em um novo arquivo JSON\n",
    "#         unified_json_path = os.path.join(pathjson, 'unified_pub.json')\n",
    "#         with open(unified_json_path, 'w', encoding='utf-8') as unified_file:\n",
    "#             json.dump(all_data, unified_file, ensure_ascii=False, indent=4)\n",
    "        \n",
    "#         print(f\"Arquivo unificado criado em: {unified_json_path}\")\n",
    "\n",
    "#         # Atualiza self.data com os dados unidos\n",
    "#         self.data = all_data\n",
    "\n",
    "#     def merge_publication_json_files(self, pathjson):\n",
    "#         \"\"\"\n",
    "#         This function receives a path to a JSON folder, accesses the folder's contents, searches for files\n",
    "#         containing 'publication.json' in their filename, merges their contents and saves the resulting\n",
    "#         data as a CSV file in destination folder.\n",
    "#         \"\"\"\n",
    "#         data = []\n",
    "#         # Looping through the files in the given path\n",
    "#         for filename in os.listdir(pathjson):\n",
    "#             if 'publication.json' in filename:\n",
    "#                 print(f\"Extraindo dados do arquivo {filename}...\")\n",
    "#                 # Opening the file and appending its data to the list\n",
    "#                 with open(os.path.join(pathjson, filename), 'r', encoding='utf-8') as file:\n",
    "#                     data.append(json.load(file))\n",
    "\n",
    "#         # Creating the output directory if it doesn't exist\n",
    "#         destination = os.path.join(os.getcwd(), '_data','powerbi')\n",
    "#         if not os.path.exists(destination):\n",
    "#             os.mkdir(destination)\n",
    "\n",
    "#         # Writing the merged data to a CSV file\n",
    "#         print(f\"Criando arquivo CSV...\")\n",
    "#         with open(os.path.join(destination, 'publication.csv'), 'w', encoding='utf-8', newline='') as csv_file:\n",
    "#             writer = csv.writer(csv_file)\n",
    "#             # Writing the header based on the keys of the first item in the list\n",
    "#             writer.writerow(data[0].keys())\n",
    "#             # Looping through the items in the list and writing them as rows in the CSV file\n",
    "#             for item in data:\n",
    "#                 writer.writerow(item.values())\n",
    "\n",
    "#     def exportar_para_csv(self, nome_arquivo='publicacoes.csv'):\n",
    "#         linhas = self.processar_publicacoes()\n",
    "#         df = pd.DataFrame(linhas, columns=self.colunas)\n",
    "#         filepathcsv = os.path.join(\"./\",\"_data\",\"powerbi\",nome_arquivo)\n",
    "#         df.to_csv(filepathcsv, index=False)\n",
    "#         print(f'Arquivo criado com sucesso em {filepathcsv}')\n",
    "\n",
    "#     def ler_csv_dados(self, pathdata,filename):\n",
    "#         filepath = os.path.join(pathdata,filename)\n",
    "#         df_pub=pd.read_csv(filepath)\n",
    "#         tipos = df_pub['tipo_producao'].value_counts()\n",
    "#         qualis=df_pub['estrato_qualis'].value_counts()  \n",
    "#         quantidade_nan = df_pub['estrato_qualis'].isna().sum()\n",
    "#         tipos_qualis = qualis.count()\n",
    "#         percentual_nan=np.round(quantidade_nan/tipos.sum()*100,1)\n",
    "#         print(f\"\\n{tipos.sum()} linhas no total, distribuídas nos seguintes tipos de produção:\")\n",
    "#         print(f\"{quantidade_nan} linhas ({percentual_nan}% do total de linhas) com NaN no campo estrato_qualis\")\n",
    "#         print(tipos)\n",
    "#         ano_min=df_pub['ano'].min()\n",
    "#         ano_max=df_pub['ano'].max()\n",
    "#         print(f\"\\n{tipos.get('PERIODICO', 0)} publicações em periódicos, no período de {int(ano_min)} a {int(ano_max)}\")\n",
    "#         percentual=np.round(qualis.sum()/tipos.get('PERIODICO', 0)*100,1)\n",
    "#         print(f\"{qualis.sum()} publicações ({percentual}%) classificadas no qualis periodicos conforme estratificação:\")\n",
    "#         quantidade_nan_periodico = df_pub[df_pub['tipo_producao'] == 'PERIODICO']['estrato_qualis'].isna().sum()\n",
    "#         percentual_nan_periodico = np.round(quantidade_nan_periodico/tipos.get('PERIODICO', 0)*100,1)\n",
    "#         print(f\"{quantidade_nan_periodico} publicações em periódicos ({percentual_nan_periodico}%) com valor 'NaN' no estrato_qualis\\n\")\n",
    "#         print(qualis)\n",
    "#         return df_pub\n",
    "\n",
    "#     def ler_xls_dados(self, pathdata,filename):\n",
    "#         filepath = os.path.join(pathdata,filename)\n",
    "#         df_pub=pd.read_excel(filepath)\n",
    "#         tipos = df_pub['tipo_producao'].value_counts()\n",
    "#         qualis=df_pub['estrato_qualis'].value_counts()\n",
    "#         tipos_qualis = qualis.count()\n",
    "#         print(f\"\\n{tipos.sum()} linhas no total, distribuídas nos seguintes tipos de produção:\")\n",
    "#         print(tipos)\n",
    "#         ano_min=df_pub['ano'].min()\n",
    "#         ano_max=df_pub['ano'].max()\n",
    "#         print(f\"\\n{tipos.get('PERIODICO', 0)} publicações em periódicos, no período de {int(ano_min)} a {int(ano_max)}\")\n",
    "#         percentual=np.round(qualis.sum()/tipos.get('PERIODICO', 0)*100,1)\n",
    "#         print(f\"{qualis.sum()} publicações ({percentual}%) classificadas no qualis periodicos conforme estratificação:\")\n",
    "#         print(qualis)\n",
    "#         return df_pub\n",
    "\n",
    "#     def sigla_producao(self, tipo_producao, separador=\"\"):\n",
    "#         \"\"\"\n",
    "#         Função para converter os valores da coluna 'tipo_producao' em siglas, desconsiderando preposições,\n",
    "#         fazendo split de 'tipo_producao' em palavras também pelo caractere \"_\".\n",
    "        \n",
    "#         Parâmetros:\n",
    "#         - tipo_producao: O valor da coluna 'tipo_producao'.\n",
    "#         - separador: O caractere para separar as iniciais. Padrão é \"_\".\n",
    "        \n",
    "#         Retorna:\n",
    "#         - Uma string que é a sigla formada pelas iniciais das palavras em 'tipo_producao', desconsiderando preposições.\n",
    "#         \"\"\"\n",
    "#         # Lista de preposições para serem ignoradas\n",
    "#         preposicoes = ['e', 'de', 'do', 'da', 'dos', 'das', 'em', 'na', 'no', 'nas', 'nos', 'por', 'para', 'com']\n",
    "\n",
    "#         # Mapeamento de exemplo conforme as siglas fornecidas\n",
    "#         mapeamento_siglas = {\n",
    "#             \"DTPB\": 1, #DEMAIS_TIPOS_DE_PRODUCAO_BIBLIOGRAFICA \n",
    "#             \"TJ\": 2, #TEXTO_EM_JORNAIS\n",
    "#             \"E\": 3, #EVENTO\n",
    "#             \"CL\": 4, #CAPITULO_DE_LIVRO\n",
    "#             \"L\": 5, #LIVRO\n",
    "#             \"AA\": 6, #ARTIGO_ACEITO\n",
    "#             \"P\": 7, #PERIODICO\n",
    "#         }\n",
    "\n",
    "#         # Fazendo split por espaço e por underscore\n",
    "#         palavras = tipo_producao.replace('_', ' ').replace('-', ' ').split()\n",
    "\n",
    "#         # Inicializar a lista de iniciais\n",
    "#         iniciais = []\n",
    "\n",
    "#         for palavra in palavras:\n",
    "#             # Verificar se a palavra não é uma preposição e não está vazia\n",
    "#             if palavra.lower() not in preposicoes and palavra:\n",
    "#                 # Adicionar a inicial em maiúsculo à lista de iniciais\n",
    "#                 iniciais.append(palavra[0].upper())\n",
    "\n",
    "#         # Juntar as iniciais para formar a sigla\n",
    "#         sigla = \"\".join(iniciais)\n",
    "\n",
    "#         # Aplicar o mapeamento para encontrar o número correspondente à sigla\n",
    "#         numero = mapeamento_siglas.get(sigla, \"\")\n",
    "\n",
    "#         # Retornar a string formatada com o número e a sigla\n",
    "#         return f\"{numero}-{sigla}\"  \n",
    "\n",
    "#     def sigla_qualis(self, estrato_qualis, separador=\"\"):\n",
    "#         \"\"\"\n",
    "#         Função para converter os valores da coluna 'estrato_qualis' em siglas com números de ordenação,\n",
    "        \n",
    "#         Parâmetros:\n",
    "#         - estrato_qualis: O valor da coluna 'estrato_qualis'.\n",
    "#         - separador: O caractere para separar as iniciais. Padrão é \"_\".\n",
    "        \n",
    "#         Retorna:\n",
    "#         - Uma string que é a sigla formada pelas iniciais das palavras em 'estrato_qualis' antecedida por seu número de ordenação.\n",
    "#         \"\"\"\n",
    "\n",
    "#         # Mapeamento de exemplo conforme as siglas fornecidas\n",
    "#         mapeamento_siglas = {\n",
    "#             \"C\": 1,\n",
    "#             \"B4\": 2,\n",
    "#             \"B3\": 3,\n",
    "#             \"B2\": 4,\n",
    "#             \"B1\": 5,\n",
    "#             \"B2\": 6,\n",
    "#             \"B1\": 7,\n",
    "#             \"A4\": 8,\n",
    "#             \"A3\": 9,\n",
    "#             \"A2\": 10,\n",
    "#             \"A1\": 11,\n",
    "#         }\n",
    "\n",
    "#         # Aplicar o mapeamento para encontrar o número correspondente à sigla\n",
    "#         numero = mapeamento_siglas.get(estrato_qualis, \"\")\n",
    "\n",
    "#         # Retornar a string formatada com o número e a sigla\n",
    "#         return f\"{numero}-{estrato_qualis}\"\n",
    "\n",
    "#     def agrupar_publicacoes(self, filename):\n",
    "#         # Caminho para o arquivo CSV\n",
    "#         pathfilename = os.path.join(os.getcwd(), '_data', 'powerbi', filename)\n",
    "#         df = pd.read_csv(pathfilename)\n",
    "\n",
    "#         # Use .loc para modificar o DataFrame diretamente e evitar o aviso\n",
    "#         df.loc[:, 'sigla_producao'] = df['tipo_producao'].apply(lambda x: self.sigla_producao(x))\n",
    "#         df_publicacoes = df[['idLattes','ano','sigla_producao']]\n",
    "\n",
    "#         # Agrupar por 'ano', 'natureza' e orientador e contar as ocorrências\n",
    "#         contagem_publicacoes = df_publicacoes.groupby(['ano','sigla_producao','idLattes']).size().reset_index(name='contagem')\n",
    "\n",
    "#         # Retornar a contagem de orientações por tipo e por ano\n",
    "#         return contagem_publicacoes\n",
    "\n",
    "#     def agrupar_qualis(self, filename):\n",
    "#         # Caminho para o arquivo CSV\n",
    "#         pathfilename = os.path.join(os.getcwd(), '_data', 'powerbi', filename)\n",
    "#         df = pd.read_csv(pathfilename)\n",
    "\n",
    "#         # # Use .loc para modificar o DataFrame diretamente e evitar o aviso\n",
    "#         df.loc[:, 'estrato_qualis'] = df['estrato_qualis'].apply(lambda x: self.sigla_qualis(x))\n",
    "#         df_publicacoes = df[['idLattes','ano','estrato_qualis']]\n",
    "\n",
    "#         # Remover todas as linhas que contêm pelo menos um valor NaN\n",
    "#         df_publicacoes_limpo = df_publicacoes.dropna()\n",
    "\n",
    "#         # Agrupar por 'ano', 'natureza' e orientador e contar as ocorrências\n",
    "#         contagem_qualis = df_publicacoes_limpo.groupby(['ano','estrato_qualis','idLattes']).size().reset_index(name='contagem')\n",
    "\n",
    "#         # Retornar a contagem de orientações por tipo e por ano\n",
    "#         return contagem_qualis\n",
    "\n",
    "#     def plotar_producoes_barras_empilhadas(self, filename):\n",
    "#         contagem_publicacoes = self.agrupar_publicacoes(filename)\n",
    "#         fig = make_subplots(rows=1, cols=1)\n",
    "#         anos = sorted(contagem_publicacoes['ano'].unique())\n",
    "\n",
    "#         mapeamento_siglas_para_numeros = {\n",
    "#             \"1-DTPB\": 1, # Demais tipos de produção bibliográfica\n",
    "#             \"2-TJ\": 2, # Texto em jornais\n",
    "#             \"3-E\": 3, # Evento\n",
    "#             \"4-CL\": 4, # Capítulo de Livro\n",
    "#             \"5-L\": 5, # Livro\n",
    "#             \"6-AA\": 6, # Artigo Aceito\n",
    "#             \"7-P\": 7, # Periódico\n",
    "#         }\n",
    "\n",
    "#         naturezas_ordenadas = sorted(contagem_publicacoes['sigla_producao'].unique(), key=lambda x: mapeamento_siglas_para_numeros.get(x, 999))\n",
    "\n",
    "#         for natureza in naturezas_ordenadas:\n",
    "#             contagem_por_ano = []\n",
    "#             labels_por_ano = [] # Para armazenar os rótulos de dados\n",
    "#             for ano in anos:\n",
    "#                 contagem = contagem_publicacoes[(contagem_publicacoes['ano'] == ano) & (contagem_publicacoes['sigla_producao'] == natureza)]['contagem'].sum()\n",
    "#                 if mapeamento_siglas_para_numeros.get(natureza, 999) in [1, 2, 3, 4]:\n",
    "#                     contagem = -contagem\n",
    "#                 contagem_por_ano.append(contagem)\n",
    "#                 labels_por_ano.append(str(contagem)) # Convertendo a contagem em string para usar como rótulo\n",
    "            \n",
    "#             # Adicionar a barra ao gráfico com rótulos de dados\n",
    "#             fig.add_trace(go.Bar(x=anos, y=contagem_por_ano, name=natureza, text=labels_por_ano, textposition='auto'))\n",
    "\n",
    "#         # Atualizar o layout para permitir barras empilhadas, ajustar o eixo Y para mostrar valores negativos, e garantir que todos os anos sejam mostrados no eixo X\n",
    "#         fig.update_layout(\n",
    "#             barmode='relative',\n",
    "#             title_text='Contagem de Produções por Tipo e Ano (Produção de divulgação plotadas abaixo do eixo X)',\n",
    "#             xaxis_title=\"Ano\",\n",
    "#             yaxis_title=\"Quantidade de Produções Biliográficas\",\n",
    "#             yaxis=dict(zeroline=True, zerolinewidth=2, zerolinecolor='black'),\n",
    "#         )        \n",
    "#         # Garantir que todos os anos apareçam na barra de rótulos do eixo X\n",
    "#         fig.update_xaxes(tickmode='array', tickvals=anos)\n",
    "#         fig.show()\n",
    "\n",
    "\n",
    "#     def plotar_qualis_barras_empilhadas(self, filename):\n",
    "#         contagem_publicacoes = self.agrupar_qualis(filename)\n",
    "#         contagem_publicacoes.replace(\"-nan\", np.nan, inplace=True)\n",
    "#         contagem_publicacoes.dropna(inplace=True)\n",
    "#         fig = make_subplots(rows=1, cols=1)\n",
    "#         anos = sorted(contagem_publicacoes['ano'].unique())\n",
    "\n",
    "#         mapeamento_siglas_para_numeros = {\n",
    "#             \"1-C\": 1, \"2-B4\": 2, \"3-B3\": 3, \"4-B2\": 4, \"5-B1\": 5,\n",
    "#             \"6-B2\": 6, \"7-B1\": 7, \"8-A4\": 8, \"9-A3\": 9, \"10-A2\": 10, \"11-A1\": 11,\n",
    "#         }\n",
    "#         naturezas_ordenadas = sorted(contagem_publicacoes['estrato_qualis'].unique(), key=lambda x: mapeamento_siglas_para_numeros.get(x, 999))\n",
    "        \n",
    "#         # Obter a paleta de cores 'Greens'\n",
    "#         cores = px.colors.sequential.Greens\n",
    "#         # Certificar que temos cores suficientes para todas as barras, repetindo a paleta se necessário\n",
    "#         num_barras = len(naturezas_ordenadas)\n",
    "#         cores_repetidas = cores * (num_barras // len(cores) + 1)\n",
    "        \n",
    "#         for index, natureza in enumerate(naturezas_ordenadas):\n",
    "#             contagem_por_ano = []\n",
    "#             for ano in anos:\n",
    "#                 contagem = contagem_publicacoes[(contagem_publicacoes['ano'] == ano) & (contagem_publicacoes['estrato_qualis'] == natureza)]['contagem'].sum()\n",
    "#                 if mapeamento_siglas_para_numeros.get(natureza, 999) in [1, 2, 3, 4, 5, 6, 7]:\n",
    "#                     contagem = -contagem\n",
    "#                 contagem_por_ano.append(contagem)\n",
    "            \n",
    "#             # Usar uma cor da paleta para cada barra\n",
    "#             fig.add_trace(go.Bar(x=anos, y=contagem_por_ano, name=natureza, marker_color=cores_repetidas[index]))\n",
    "\n",
    "#         fig.update_layout(\n",
    "#             barmode='relative',\n",
    "#             title_text='Contagem de Produções por Estrato Qualis e Ano (Qualis abaixo de B plotado do eixo X)',\n",
    "#             xaxis_title=\"Ano\",\n",
    "#             yaxis_title=\"Quantidade de Publicações\",\n",
    "#             yaxis=dict(zeroline=True, zerolinewidth=2, zerolinecolor='black'),\n",
    "#         )\n",
    "#         # Garantir que todos os anos apareçam na barra de rótulos do eixo X\n",
    "#         fig.update_xaxes(tickmode='array', tickvals=anos)        \n",
    "#         fig.show()\n",
    "\n",
    "# class PreparadorDeOrientacoes():\n",
    "#     def __init__(self):\n",
    "#         self.data = []\n",
    "#         self.colunas = ['id_lattes_orientadores', 'tipo_orientacao', 'natureza', 'titulo', 'idioma', 'ano', 'id_lattes_aluno', 'nome_aluno', 'instituicao', 'pais', 'curso', 'codigo_do_curso', 'bolsa', 'agencia_financiadora', 'codigo_agencia_financiadora', 'nome_orientadores', 'tags', 'Hash']\n",
    "#         self.pathjson = os.path.join('_data','in_json')\n",
    "#         # self.filename = '863.advise.json'\n",
    "\n",
    "#         # Abrir o arquivo e carregando o JSON\n",
    "#     def open_file(self, filename):\n",
    "#         with open(os.path.join(self.pathjson, filename), 'r', encoding='utf-8') as file:\n",
    "#             data = json.load(file)\n",
    "        \n",
    "#         linhas_achatadas = self.extrair_orientacoes(data)\n",
    "#         df = pd.DataFrame(linhas_achatadas)\n",
    "#         df.to_csv('orientacoes_achatadas.csv', index=False)\n",
    "#         return df\n",
    "    \n",
    "#     def agrupar_orientacoes(self, filename):\n",
    "#         # Caminho para o arquivo JSON\n",
    "#         pathfilename = os.path.join('_data', 'in_json', filename)\n",
    "#         # dict_orientacoes = pd.read_json(pathfilename)\n",
    "\n",
    "#         # Carregar o JSON e aplicar a função\n",
    "#         with open(pathfilename, 'r', encoding='utf-8') as file:\n",
    "#             data = json.load(file)\n",
    "\n",
    "#         linhas_achatadas = self.extrair_orientacoes(data)\n",
    "#         df = pd.DataFrame(linhas_achatadas)\n",
    "\n",
    "#         # Salvar os dados achatados em um CSV\n",
    "#         df.to_csv('orientacoes_achatadas.csv', index=False)\n",
    "\n",
    "#         # Use .loc para modificar o DataFrame diretamente e evitar o aviso\n",
    "#         df.loc[:, 'sigla_natureza'] = df['natureza'].apply(lambda x: self.sigla_natureza(x))\n",
    "#         df_orientacoes = df[['id_lattes_orientadores','ano','sigla_natureza']]\n",
    "\n",
    "#         # Agrupar por 'ano', 'natureza' e orientador e contar as ocorrências\n",
    "#         contagem_orientacoes = df_orientacoes.groupby(['ano','sigla_natureza','id_lattes_orientadores']).size().reset_index(name='contagem')\n",
    "\n",
    "#         # Retornar a contagem de orientações por tipo e por ano\n",
    "#         return contagem_orientacoes\n",
    "\n",
    "#     # Prosseguir com a definição e uso da função para extrair as orientações\n",
    "#     def extrair_orientacoes(self, json_data):\n",
    "#         colunas = self.colunas\n",
    "#         linhas = []\n",
    "\n",
    "#         # Iterar sobre cada tipo de orientação e ano\n",
    "#         for tipo_orientacao, anos in json_data.items():\n",
    "#             for ano, orientacoes in anos.items():\n",
    "#                 for orientacao in orientacoes:\n",
    "#                     # Preparar um dicionário para cada linha de acordo com as colunas definidas\n",
    "#                     linha = {}\n",
    "#                     # Adicionar dados específicos da orientação\n",
    "#                     for campo in orientacao:\n",
    "#                         if campo in colunas:\n",
    "#                             linha[campo] = orientacao[campo]\n",
    "#                     # Tratar 'id_lattes_orientadores' como uma lista, juntar os IDs com vírgula se houver mais de um\n",
    "#                     linha['id_lattes_orientadores'] = ', '.join(orientacao.get('id_lattes_orientadores', []))\n",
    "#                     # Adicionar o tipo de orientação como uma coluna\n",
    "#                     linha['tipo_orientacao'] = tipo_orientacao\n",
    "#                     # Adicionar o ano, garantindo que sobreponha qualquer valor de 'ano' nos dados individuais\n",
    "#                     linha['ano'] = ano\n",
    "#                     linhas.append(linha)\n",
    "\n",
    "#         return linhas\n",
    "\n",
    "#     def sigla_natureza(self, natureza, separador=\"\"):\n",
    "#         \"\"\"\n",
    "#         Função para converter os valores da coluna 'natureza' em siglas, desconsiderando preposições,\n",
    "#         fazendo split de 'natureza' em palavras também pelo caractere \"_\".\n",
    "        \n",
    "#         Parâmetros:\n",
    "#         - natureza: O valor da coluna 'natureza'.\n",
    "#         - separador: O caractere para separar as iniciais. Padrão é \"_\".\n",
    "        \n",
    "#         Retorna:\n",
    "#         - Uma string que é a sigla formada pelas iniciais das palavras em 'natureza', desconsiderando preposições.\n",
    "#         \"\"\"\n",
    "#         # Lista de preposições para serem ignoradas\n",
    "#         preposicoes = ['e', 'de', 'do', 'da', 'dos', 'das', 'em', 'na', 'no', 'nas', 'nos', 'por', 'para', 'com']\n",
    "\n",
    "#         # Mapeamento de exemplo conforme as siglas fornecidas\n",
    "#         mapeamento_siglas = {\n",
    "#             \"OON\": 1, #Orientações de Outra Natureza\n",
    "#             \"IC\": 2, #Iniciação Científica\n",
    "#             \"MCCAE\": 3, #Monografia de Conclusão Curso de Atualização ou Especialização\n",
    "#             \"SPD\": 4, #\n",
    "#             \"TCCG\": 5, #Trabalho de Conclusão de Curso de Graduação\n",
    "#             \"DM\": 6, #Dissertação de Mestrado\n",
    "#             \"TD\": 7, #Tese de Doutorado\n",
    "#         }\n",
    "\n",
    "#         # Fazendo split por espaço e por underscore\n",
    "#         palavras = natureza.replace('_', ' ').replace('-', ' ').split()\n",
    "\n",
    "#         # Inicializar a lista de iniciais\n",
    "#         iniciais = []\n",
    "\n",
    "#         for palavra in palavras:\n",
    "#             # Verificar se a palavra não é uma preposição e não está vazia\n",
    "#             if palavra.lower() not in preposicoes and palavra:\n",
    "#                 # Adicionar a inicial em maiúsculo à lista de iniciais\n",
    "#                 iniciais.append(palavra[0].upper())\n",
    "\n",
    "#         # Juntar as iniciais para formar a sigla\n",
    "#         sigla = \"\".join(iniciais)\n",
    "\n",
    "#         # Aplicar o mapeamento para encontrar o número correspondente à sigla\n",
    "#         numero = mapeamento_siglas.get(sigla, \"Desconhecido\")\n",
    "\n",
    "#         # Retornar a string formatada com o número e a sigla\n",
    "#         return f\"{numero}-{sigla}\"     \n",
    "\n",
    "#     def plotar_orientacoes_barras_agrupadas(self, filename):\n",
    "#         # montar dataframe com agrupamento de orientações por tipo por ano no programa\n",
    "#         contagem_orientacoes = self.agrupar_orientacoes(filename)\n",
    "\n",
    "#         # Criar uma figura com subplots\n",
    "#         fig = make_subplots(rows=1, cols=1)\n",
    "\n",
    "#         # Encontrar anos e naturezas únicos para as orientações\n",
    "#         anos = sorted(contagem_orientacoes['ano'].unique())\n",
    "\n",
    "#         # Mapeamento de exemplo conforme as siglas fornecidas\n",
    "#         mapeamento_siglas = {\n",
    "#             \"OON\": 1,\n",
    "#             \"IC\": 2,\n",
    "#             \"MCCAE\": 3,\n",
    "#             \"SPD\": 4,\n",
    "#             \"TCCG\": 5,\n",
    "#             \"DM\": 6,\n",
    "#             \"TD\": 7,\n",
    "#         }\n",
    "\n",
    "#         # Ordenar as naturezas com base nos números associados em mapeamento_siglas\n",
    "#         mapeamento_siglas_para_numeros = {sigla: int(sigla.split('-')[0]) for sigla in contagem_orientacoes['sigla_natureza'].unique()}\n",
    "#         naturezas_ordenadas = sorted(contagem_orientacoes['sigla_natureza'].unique(), key=lambda x: mapeamento_siglas_para_numeros.get(x, 999))\n",
    "\n",
    "#         # Criar uma barra para cada tipo de orientação em cada ano\n",
    "#         for natureza in naturezas_ordenadas:\n",
    "#             contagem_por_ano = []\n",
    "#             for ano in anos:\n",
    "#                 # Somar as contagens para cada ano e natureza\n",
    "#                 contagem = contagem_orientacoes[(contagem_orientacoes['ano'] == ano) & (contagem_orientacoes['sigla_natureza'] == natureza)]['contagem'].sum()\n",
    "#                 contagem_por_ano.append(contagem)\n",
    "            \n",
    "#             # Adicionar a barra ao gráfico\n",
    "#             fig.add_trace(go.Bar(x=anos, y=contagem_por_ano, name=natureza))\n",
    "\n",
    "#         # Atualizar o layout para permitir barras agrupadas\n",
    "#         fig.update_layout(barmode='group', title_text='Contagem de Orientações no Programa por Tipo e Ano', xaxis_title=\"Ano\", yaxis_title=\"Quantidade de Orientações\")\n",
    "\n",
    "#         # Mostrar o gráfico\n",
    "#         fig.show()\n",
    "\n",
    "\n",
    "#     def plotar_orientacoes_barras_empilhadas(self, filename):\n",
    "#         # montar dataframe com agrupamento de orientações por tipo por ano no programa\n",
    "#         contagem_orientacoes = self.agrupar_orientacoes(filename)\n",
    "        \n",
    "#         # Criar uma figura com subplots\n",
    "#         fig = make_subplots(rows=1, cols=1)\n",
    "\n",
    "#         # Encontrar anos únicos para as orientações\n",
    "#         anos = sorted(contagem_orientacoes['ano'].unique())\n",
    "\n",
    "#         # Mapeamento para siglas de tipos de orientações\n",
    "#         mapeamento_siglas = {\n",
    "#             \"OON\": 1,\n",
    "#             \"IC\": 2,\n",
    "#             \"MCCAE\": 3,\n",
    "#             \"SPD\": 4,\n",
    "#             \"TCCG\": 5,\n",
    "#             \"DM\": 6,\n",
    "#             \"TD\": 7,\n",
    "#         }\n",
    "\n",
    "#         # Mapeamento para ordenar siglas por duração/complexidade\n",
    "#         mapeamento_siglas_para_numeros = {\n",
    "#             \"1-OON\": 1,\n",
    "#             \"2-IC\": 2,\n",
    "#             \"3-MCCAE\": 3,\n",
    "#             \"4-SPD\": 4,\n",
    "#             \"5-TCCG\": 5,\n",
    "#             \"6-DM\": 6,\n",
    "#             \"7-TD\": 7,\n",
    "#         }\n",
    "\n",
    "#         # Ordenar as naturezas baseando-se no número extraído da sigla\n",
    "#         naturezas_ordenadas = sorted(contagem_orientacoes['sigla_natureza'].unique(), key=lambda x: mapeamento_siglas_para_numeros.get(x, 999))\n",
    "\n",
    "#         # Criar uma barra para cada tipo de orientação em cada ano, seguindo a ordem definida\n",
    "#         for natureza in naturezas_ordenadas:\n",
    "#             contagem_por_ano = []\n",
    "#             for ano in anos:\n",
    "#                 # Somar as contagens para cada ano e natureza\n",
    "#                 contagem = contagem_orientacoes[(contagem_orientacoes['ano'] == ano) & (contagem_orientacoes['sigla_natureza'] == natureza)]['contagem'].sum()\n",
    "#                 # Se a sigla estiver associada ao número 1 ou 2, tornar a contagem negativa\n",
    "#                 if mapeamento_siglas_para_numeros.get(natureza, 999) in [1, 2, 3, 4]:\n",
    "#                     contagem = -contagem\n",
    "#                 contagem_por_ano.append(contagem)\n",
    "            \n",
    "#             # Adicionar a barra ao gráfico\n",
    "#             fig.add_trace(go.Bar(x=anos, y=contagem_por_ano, name=natureza))\n",
    "\n",
    "#         # Atualizar o layout para permitir barras empilhadas e ajustar o eixo Y para mostrar valores negativos\n",
    "#         fig.update_layout(\n",
    "#             barmode='relative',  # Usar 'relative' para empilhar incluindo valores negativos\n",
    "#             title_text='Contagem de Orientações por Tipo e Ano (Orientações de curta duração plotadas abaixo do eixo X)',\n",
    "#             xaxis_title=\"Ano\",\n",
    "#             yaxis_title=\"Quantidade de Orientações\",\n",
    "#             yaxis=dict(zeroline=True, zerolinewidth=2, zerolinecolor='black'),  # Destacar a linha zero\n",
    "#         )\n",
    "\n",
    "#         # Mostrar o gráfico\n",
    "#         fig.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8007a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# path = \"./\"\n",
    "# print(f\"     Pasta corrente: {path}\")\n",
    "# pathjson = os.path.join(path,'_data','in_json')\n",
    "# print(f\"Pasta arquivos JSON: {pathjson}\")\n",
    "# try:\n",
    "#     pathdata = os.path.join(path,'_data','powerbi')\n",
    "#     print(f\" Pasta de dados CSV: {pathdata}\")\n",
    "# except:\n",
    "#     print('Pasta de dados ainda não existe.')\n",
    "\n",
    "# print(\"\\nConteúdo da pasta JSON:\")\n",
    "# list(os.listdir(pathjson))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aac29e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## Descompactar arquivo zipado na pasta JSON\n",
    "# prep_pub = PreparadorDePublicacoes()\n",
    "# pathfilezip = '_data/in_zip/890.files.zip'\n",
    "# destination = prep_pub.extract_zips(pathfilezip)\n",
    "\n",
    "# ## Unir todos aquivos de publicações (caso haja mais de um com final publication.json na pasta serão mesclados):\n",
    "# prep_pub.find_and_merge_publication_json_files(pathjson)\n",
    "\n",
    "# ## Mapear arquivo de dados para PowerBI a partir do JSON unificado\n",
    "# linhas = prep_pub.processar_publicacoes()\n",
    "# prep_pub.exportar_para_csv()\n",
    "\n",
    "# ## Ler e montar análise exploratória\n",
    "# filename='publicacoes.csv'\n",
    "# df_pub = prep_pub.ler_csv_dados(pathdata,filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c61df53c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# filename='890.advise.json'\n",
    "# pathjson = os.path.join('_data','in_json')\n",
    "# pathfilename = os.path.join(pathjson,filename)\n",
    "# print(pathfilename)\n",
    "# dict_orientacoes = pd.read_json(pathfilename)\n",
    "# print(f'{len(dict_orientacoes):02} dicionários com dados de orientações')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20d4ec18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dict_orientacoes.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f2c4685",
   "metadata": {},
   "outputs": [],
   "source": [
    "# prep_ort = PreparadorDeOrientacoes()\n",
    "# prep_ort.plotar_orientacoes_barras_agrupadas(filename)\n",
    "# prep_ort.plotar_orientacoes_barras_empilhadas(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46f5e309",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pathcsv = os.path.join('_data','powerbi')\n",
    "# os.listdir(pathcsv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be258ab8",
   "metadata": {},
   "source": [
    "## Demais passos\n",
    "\n",
    "Calcular índice de publicação em conjunto com alunos do programa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1574aac1",
   "metadata": {},
   "source": [
    "- Levantar nome dos discentes do programa\n",
    "- Levantar os nomes de autores nas publicações de docentes\n",
    "- Identificar por similadidade as publicações onde constam nome de alunos do programa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb00d652",
   "metadata": {},
   "source": [
    "    Padronizar nomes de autores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94552058",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def limpar_nomes(linha_texto):\n",
    "#     '''\n",
    "#     Retira erros e sujeira da string formada pela lista de nomes de autor dos artigos retirada do Lattes\n",
    "#      Recebe: Uma string com os nomes de autor\n",
    "#     Retorna: Uma string com os nomes de autor, removidas preposições, acentos, e demais erros pontuais\n",
    "#     '''\n",
    "#     import unicodedata\n",
    "#     import re\n",
    "#     # print('               Analisando:',linha_texto)\n",
    "#     string = linha_texto.replace('Network for Genomic Surveillance in South Africa;Network for Genomic Surveillance in South Africa (NGS-SA);10.1002/jmv.27190;','')\n",
    "#     string = string.replace('Autores: ','').replace('(Org)','').replace('(Org.)','').replace('et. al.','').replace('et al','').replace('(Org).','').replace('.','').replace('\\'','')\n",
    "#     string = string.replace(',,,',',').replace(',,',',').replace(';',', ').replace('-',' ').replace('S?', 'SA').replace('S?', 'SA').replace('ARA?JO', 'ARAUJO').replace('FL?VIO','FLAVIO').replace('F?BIO','FABIO').replace('VIT?RIO','VITORIO')\n",
    "#     string = re.sub(r'[0-9]+', '', string)\n",
    "#     partes_string = string.split(' ')\n",
    "\n",
    "#     ## Retirar partes de nomes caso sejam preposições\n",
    "#     preposicoes = ['da', 'de', 'do', 'das', 'dos', ' e ']\n",
    "#     string = ' '.join(x for x in partes_string if x.lower() not in preposicoes)\n",
    "\n",
    "#     ## Retirar símbolos não unicode, como acentuação gráfica e cedilha\n",
    "#     string = ''.join(ch for ch in unicodedata.normalize('NFKD', string) if not unicodedata.combining(ch))\n",
    "    \n",
    "#     ## Retirar iniciais juntas, separando-as com espaço em branco\n",
    "#     letras_duasconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2}$')            # Duas Letras consoantes maiúsculas juntas do início ao final da string\n",
    "#     letras_tresconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3}$')            # Três Letras consoantes maiúsculas juntas do início ao final da string\n",
    "#     letras_duasconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2},$')       # Duas Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "#     letras_tresconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3},$')       # Três Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "    \n",
    "#     partes_nome=[]\n",
    "#     for j in string.split(' '):\n",
    "#         div_ltrduasconsnts = letras_duasconsnts.findall(j)\n",
    "#         div_ltrtriplicadas = letras_tresconsnts.findall(j)\n",
    "#         div_ltrduasconsntsvirg = letras_duasconsntsvirg.findall(j)\n",
    "#         div_ltrtresconsntsvirg = letras_tresconsntsvirg.findall(j)\n",
    "#         if div_ltrduasconsnts or div_ltrtriplicadas:\n",
    "#             iniciais_separadas = ' '.join(x for x in j)\n",
    "#             partes_nome.append(iniciais_separadas)\n",
    "#         elif div_ltrduasconsntsvirg or div_ltrtresconsntsvirg:\n",
    "#             iniciais_separadas = ' '.join(x for x in j[:-1])\n",
    "#             partes_nome.append(iniciais_separadas+',')\n",
    "#         else:\n",
    "#             partes_nome.append(j)\n",
    "#     string = ' '.join(x for x in partes_nome).strip()\n",
    "#     return string\n",
    "\n",
    "\n",
    "\n",
    "# def padronizar_nome(linha_texto):\n",
    "#     '''\n",
    "#     Procura sobrenomes e abreviaturas e monta nome completo\n",
    "#      Recebe: String com todos os sobrenomes e nomes, abreviados ou não\n",
    "#     Retorna: Nome completo no formato padronizado em SOBRENOME AGNOME, Partes de nomes\n",
    "#       Autor: Marcos Aires (Mar.2022)\n",
    "#     '''\n",
    "#     import unicodedata\n",
    "#     import re\n",
    "#     # print('               Analisando:',linha_texto)\n",
    "#     partes_string = linha_texto.split(' ')\n",
    "\n",
    "#     ## Retirar partes de nomes caso sejam preposições\n",
    "#     preposicoes = ['da', 'de', 'do', 'das', 'dos', ' e ']\n",
    "#     string = ' '.join(x for x in partes_string if x.lower() not in preposicoes)\n",
    "\n",
    "#     ## Retirar símbolos não unicode, como acentuação gráfica e cedilha\n",
    "#     string = ''.join(ch for ch in unicodedata.normalize('NFKD', string) if not unicodedata.combining(ch))\n",
    "    \n",
    "#     ## Expressões regulares para encontrar padrões de divisão de nomes de autores\n",
    "#     sobrenome_inicio   = re.compile(r'^[A-ZÀ-ú-a-z]+,')                  # Sequência de letras maiúsculas no início da string\n",
    "#     sobrenome_composto = re.compile(r'^[A-ZÀ-ú-a-z]+[ ][A-ZÀ-ú-a-z]+,')  # Duas sequências de letras no início da string, separadas por espaço, seguidas por vírgula\n",
    "#     letra_abrevponto   = re.compile(r'^[A-Z][.]')                        # Uma letra maiúscula no início da string, seguida por ponto\n",
    "#     letra_abrevespaco  = re.compile(r'^[A-Z][ ]')                        # Uma letra maiúscula no início da string, seguida por espaço\n",
    "#     letras_dobradas    = re.compile(r'[A-Z]{2}')                         # Duas letras maiúsculas juntas\n",
    "#     letras_dobradasini = re.compile(r'[A-Z]{2}[ ]')                      # Duas letras maiúsculas juntas, seguidas por espaço\n",
    "#     letras_dobradasfim = re.compile(r'[ ][A-Z]{2}')                      # Duas letras maiúsculas juntas, precedidas por espaço\n",
    "\n",
    "#     ## Expressões regulares para encontrar iniciais juntas, separando-as com espaço em branco\n",
    "#     letras_duasconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2}$')            # Duas Letras consoantes maiúsculas juntas do início ao final da string\n",
    "#     letras_tresconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3}$')            # Três Letras consoantes maiúsculas juntas do início ao final da string\n",
    "#     letras_duasconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2},$')       # Duas Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "#     letras_tresconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3},$')       # Três Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "\n",
    "#     ## Agnomes e preprosições a tratar, agnomes vão em maiúsculas para sobrenome e preposições vão em minúsculas para restante das partes de nomes\n",
    "#     nomes=[]\n",
    "#     agnomes       = ['NETO','JUNIOR','FILHO','SEGUNDO','TERCEIRO','SOBRINHO']\n",
    "#     preposicoes   = ['de','da','do','das','dos', ' e ']\n",
    "#     nome_completo = ''\n",
    "    \n",
    "#     ## Ajustar lista de termos, identificar sobrenomes compostos e ajustar sobrenome com ou sem presença de vírgula\n",
    "#     div_sobrenome   = sobrenome_inicio.findall(string)\n",
    "#     div_sbrcomposto = sobrenome_composto.findall(string)\n",
    "    \n",
    "#     # print('-'*100)\n",
    "#     # print('                 Recebido:',string)\n",
    "    \n",
    "#     ## Caso haja vírgulas na string, tratar sobrenomes e sobrenomes compostos\n",
    "#     if div_sobrenome != [] or div_sbrcomposto != []:\n",
    "#         # print('CASO_01: Há víruglas na string')\n",
    "#         div = string.split(', ')\n",
    "#         sobrenome     = div[0].strip().upper()\n",
    "#         try:\n",
    "#             div_espaco    = div[1].split(' ')\n",
    "#         except:\n",
    "#             div_espaco    = ['']\n",
    "#         primeiro      = div_espaco[0].strip('.').strip()\n",
    "        \n",
    "#         # print('     Dividir por vírgulas:',div)\n",
    "#         # print('      Primeira DivVirgula:',sobrenome)\n",
    "#         # print('Segunda DivVrg/DivEspaços:',div_espaco)\n",
    "#         # print('      Primeira DivEspaços:',primeiro)\n",
    "               \n",
    "#         # Caso primeiro nome seja somente duas letras maiúsculas juntas, trata-se de duas iniciais\n",
    "#         if len(primeiro)==2 or letras_tresconsnts.findall(primeiro) or letras_duasconsnts.findall(primeiro):\n",
    "#             # print('CASO_01.a: Há duas letras ou três letras consoantes juntas, são iniciais')\n",
    "#             primeiro_nome=primeiro[0].strip()\n",
    "#             # print('          C01.a1_PrimNome:',primeiro_nome)\n",
    "#             nomes.append(primeiro[1].strip().upper())\n",
    "#             try:\n",
    "#                 nomes.append(primeiro[2].strip().upper())\n",
    "#             except:\n",
    "#                 pass\n",
    "#             try:\n",
    "#                 nomes.append(primeiro[3].strip().upper())\n",
    "#             except:\n",
    "#                 pass            \n",
    "#         else:\n",
    "#             # print('CASO_01.b: Primeiro nome maior que 2 caracteres')\n",
    "#             primeiro_nome = div_espaco[0].strip().title()\n",
    "#             # print('          C01.a2_PrimNome:',primeiro_nome)\n",
    "        \n",
    "#         ## Montagem da lista de partes de nomes do meio\n",
    "#         for nome in div_espaco:\n",
    "#             # print('CASO_01.c: Para cada parte de nome da divisão por espaços após divisão por vírgula')\n",
    "#             if nome not in nomes and nome.lower()!=primeiro_nome.lower() and nome.lower() not in primeiro_nome.lower() and nome!=sobrenome:   \n",
    "#                 # print('CASO_01.c1: Se o nome não está nem como primeiro nome, nem sobrenomes')\n",
    "#                 # print(nome, len(nome))\n",
    "                \n",
    "#                 ## Avaliar se é abreviatura seguida de ponto e remover o ponto\n",
    "#                 if len(nome)<=2 and nome.lower() not in preposicoes:\n",
    "#                     # print('    C01.c1.1_Nome<=02:',nome)\n",
    "#                     for inicial in nome:\n",
    "#                         # print(inicial)\n",
    "#                         if inicial not in nomes and inicial not in primeiro_nome:\n",
    "#                             nomes.append(inicial.replace('.','').strip().title())\n",
    "#                 elif len(nome)==3 and nome.lower() not in preposicoes:\n",
    "#                         # print('    C01.c1.2_Nome==03:',nome)\n",
    "#                         for inicial in nome:\n",
    "#                             if inicial not in nomes and inicial not in primeiro_nome:\n",
    "#                                 nomes.append(inicial.replace('.','').strip().title())\n",
    "#                 else:\n",
    "#                     if nome not in nomes and nome!=primeiro_nome and nome!=sobrenome and nome!='':\n",
    "#                         if nome.lower() in preposicoes:\n",
    "#                             nomes.append(nome.replace('.','').strip().lower())\n",
    "#                         else:\n",
    "#                             nomes.append(nome.replace('.','').strip().title())\n",
    "#                         # print(nome,'|',primeiro_nome)\n",
    "                        \n",
    "#         ## Caso haja sobrenome composto que não esteja nos agnomes considerar somente primeira parte como sobrenome\n",
    "#         if div_sbrcomposto !=[] and sobrenome.split(' ')[1] not in agnomes and sobrenome.split(' ')[0].lower() not in preposicoes:\n",
    "#             # print('CASO_01.d: Sobrenome composto sem agnomes')\n",
    "#             # print(div_sbrcomposto)\n",
    "#             # print('Sobrenome composto:',sobrenome)\n",
    "            \n",
    "#             nomes.append(sobrenome.split(' ')[1].title())\n",
    "#             sobrenome = sobrenome.split(' ')[0].upper().strip()\n",
    "#             # print('Sobrenome:',sobrenome)\n",
    "            \n",
    "#             for i in nomes:\n",
    "#                 if i.lower() in sobrenome.lower():\n",
    "#                     nomes.remove(i)\n",
    "#             # print('    Nomes:',nomes)\n",
    "        \n",
    "#         ## Caso haja preposição como agnome desconsiderar e passar para final dos nomes\n",
    "#         if div_sbrcomposto !=[] and sobrenome.split(' ')[0].lower() in preposicoes:\n",
    "#             # print('CASO_01.e: Preposição no Sobrenome passar para o final dos nomes')\n",
    "#             # print('   div_sbrcomposto:', div_sbrcomposto)\n",
    "#             # print('Sobrenome composto:',div_sbrcomposto)\n",
    "            \n",
    "#             nomes.append(div_sbrcomposto[0].split(' ')[0].lower())\n",
    "#             # print('    Nomes:',nomes)\n",
    "#             sobrenome = div_sbrcomposto[0].split(' ')[1].upper().strip(',').strip()\n",
    "#             # print('Sobrenome:',sobrenome)\n",
    "            \n",
    "#             for i in nomes:\n",
    "#                 # print('CASO_01.e1: Para cada nome avaliar se o sobrenome está na lista')\n",
    "#                 if i.lower() in sobrenome.lower():\n",
    "#                     nomes.remove(i)\n",
    "#             # print('  Nomes:',nomes)\n",
    "        \n",
    "#         # print('Ao final do Caso 01')\n",
    "#         # print('    Sobrenome com vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#         # print('Primeiro nome com vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#         # print('           Lista de nomes:',nomes, len(nomes),'nomes')\n",
    "        \n",
    "#     ## Caso não haja vírgulas na string considera sobrenome o último nome da string dividida com espaço vazio\n",
    "#     else:\n",
    "#         # print('CASO_02: Não há víruglas na string')\n",
    "#         try:\n",
    "#             div = string.split(' ')\n",
    "#             # print('      Divisões por espaço:',div)\n",
    "            \n",
    "#             if div[-1] in agnomes: # nome final é um agnome\n",
    "#                 sobrenome     = div[-2].upper().strip()+' '+div[-1].upper().strip()\n",
    "#                 for i in div[1:-2]:\n",
    "#                     if i not in sobrenome and i not in preposicoes:\n",
    "#                         nomes.append(i.title().strip())\n",
    "#                     if i in preposicoes:\n",
    "#                         nomes.append(i.lower().strip())\n",
    "#             else:\n",
    "#                 if len(div[-1]) > 2:\n",
    "#                     sobrenome     = div[-1].upper().strip()\n",
    "#                     primeiro_nome = div[1].title().strip()\n",
    "#                     for i in div[1:-1]:\n",
    "#                         if i != sobrenome and i not in preposicoes:\n",
    "#                             nomes.append(i.title().strip())\n",
    "#                         if i in preposicoes:\n",
    "#                             nomes.append(i.lower().strip())\n",
    "#                 else:\n",
    "#                     sobrenome     = div[-2].upper().strip()\n",
    "#                     for i in div[-1]:\n",
    "#                         nomes.append(i.title())\n",
    "#                     primeiro_nome = nomes[0].title().strip()\n",
    "#                     for i in div[1:-1]:\n",
    "#                         if i != sobrenome and i not in preposicoes:\n",
    "#                             nomes.append(i.title().strip())\n",
    "#                         if i in preposicoes:\n",
    "#                             nomes.append(i.lower().strip())\n",
    "#         except:\n",
    "#             sobrenome = div[-1].upper().strip()\n",
    "#             for i in div[1:-1]:\n",
    "#                     if i != sobrenome and i not in preposicoes:\n",
    "#                         nomes.append(i.title().strip())\n",
    "#                     if i in preposicoes:\n",
    "#                         nomes.append(i.lower().strip())\n",
    "            \n",
    "#         if sobrenome.lower() != div[0].lower().strip():\n",
    "#             primeiro_nome=div[0].title().strip()\n",
    "#         else:\n",
    "#             primeiro_nome=''\n",
    "        \n",
    "#         # print('Ao final do Caso 02')\n",
    "#         # print('    Sobrenome sem vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#         # print('Primeiro nome sem vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#         # print('Nomes do meio sem vírgula:',nomes, len(nomes),'nomes')\n",
    "    \n",
    "#     ## Encontrar e tratar como abreviaturas termos com apenas uma ou duas letras iniciais juntas, com ou sem ponto\n",
    "#     for j in nomes:\n",
    "#         # print('CASO_03: Avaliar cada nome armazenado na variável nomes')\n",
    "#         # Procura padrões com expressões regulares na string\n",
    "#         div_sobrenome      = sobrenome_inicio.findall(j)\n",
    "#         div_sbrcomposto    = sobrenome_composto.findall(j)\n",
    "#         div_abrevponto     = letra_abrevponto.findall(j)\n",
    "#         div_abrevespaco    = letra_abrevespaco.findall(j)\n",
    "#         div_ltrdobradasini = letras_dobradasini.findall(j)\n",
    "#         div_ltrdobradasfim = letras_dobradasfim.findall(j)\n",
    "#         div_ltrdobradas    = letras_dobradas.findall(j)\n",
    "#         div_ltrduasconsnts = letras_duasconsnts.findall(j)\n",
    "#         div_ltrtriplicadas = letras_tresconsnts.findall(j)\n",
    "#         tamanho=len(j)\n",
    "#         # print('\\n', div_ltrdobradasini, div_ltrdobradasfim, tamanho, 'em:',j,len(j))\n",
    "        \n",
    "#         ## Caso houver abreviatura com uma letra em maiúscula nos nomes\n",
    "#         if div_abrevponto !=[] or tamanho==1:\n",
    "#             # print('CASO_03.1: Há abreviaturas uma letra maiúscula nos nomes')\n",
    "#             nome = j.replace('.','').strip()\n",
    "#             if nome not in nomes and nome != sobrenome and nome != primeiro_nome:\n",
    "#                 # print('CASO_03.1a: Há abreviaturas uma letra maiúscula nos nomes')\n",
    "#                 nomes.append(nome.upper())\n",
    "        \n",
    "#         ## Caso houver duas inicias juntas em maiúsculas\n",
    "#         elif div_ltrdobradasini !=[] or div_ltrdobradasfim !=[] or div_ltrdobradas !=[] :\n",
    "#             # print('CASO_03.2: Há abreviaturas uma letra maiúscula nos nomes')\n",
    "#             for letra in j:\n",
    "#                 # print('CASO_03.2a: Avaliar cada inicial do nome')\n",
    "#                 if letra not in nomes and letra != sobrenome and letra != primeiro_nome:\n",
    "#                     # print('CASO_03.2a.1: Se não estiver adicionar inicial aos nomes')\n",
    "#                     nomes.append(letra.upper())\n",
    "        \n",
    "#         # Caso haja agnomes ao sobrenome\n",
    "#         elif sobrenome in agnomes:\n",
    "#             # print('CASO_03.3: Há agnomes nos sobrenomes')\n",
    "#             sobrenome = nomes[-1].upper()+' '+sobrenome\n",
    "#             # print(sobrenome.split(' '))\n",
    "#             # print('Sobrenome composto:',sobrenome)\n",
    "#             for i in nomes:\n",
    "#                 if i.lower() in sobrenome.lower():\n",
    "#                     nomes.remove(i)\n",
    "#             # print('Nomes do meio:',nomes)\n",
    "            \n",
    "#         else:\n",
    "#             # print('CASO_03.4: Não há agnomes nos sobrenomes')\n",
    "#             if j not in nomes and j not in sobrenome and j != primeiro_nome:\n",
    "#                 if len(nomes) == 1:\n",
    "#                     nomes.append(j.upper())\n",
    "#                 elif 1 < len(nomes) <= 3:\n",
    "#                     nomes.append(j.lower())\n",
    "#                 else:\n",
    "#                     nomes.append(j.title())\n",
    "         \n",
    "#         # print('Ao final do Caso 03')\n",
    "#         # print('    Sobrenome com vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#         # print('Primeiro nome com vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#         # print('Nomes do meio com vírgula:',nomes, len(nomes),'nomes')\n",
    "        \n",
    "#     nomes_meio=' '.join([str for str in nomes]).strip()\n",
    "#     # print('        Qte nomes do meio:',nomes,len(nomes))\n",
    "    \n",
    "#     if primeiro_nome.lower() == sobrenome.lower():\n",
    "#         # print('CASO_04: Primeiro nome é igual ao sobrenome')\n",
    "#         try:\n",
    "#             primeiro_nome=nomes_meio.split(' ')[0]\n",
    "#         except:\n",
    "#             pass\n",
    "#         try:\n",
    "#             nomes_meio.remove(sobrenome)\n",
    "#         except:\n",
    "#             pass\n",
    "    \n",
    "#         # print('Ao final do caso 04')\n",
    "#         # print('    Sobrenome com vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#         # print('Primeiro nome com vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#         # print('Nomes do meio com vírgula:',nomes, len(nomes),'nomes')\n",
    "    \n",
    "#     ## Caso sobrenome seja só de 1 letra passá-lo para nomes e considerar o próximo nome como sobrenome\n",
    "#     for i in range(len(div)):\n",
    "#         if len(sobrenome)==1 or sobrenome.lower() in preposicoes:\n",
    "#             # print('CASO_05: Mudar sobrenomes até o adequado')\n",
    "#             div    = string.split(', ')\n",
    "#             # print('Divisão por vírgulas:',div)\n",
    "#             avaliar0       = div[0].split(' ')[0].strip()\n",
    "#             if 1< len(avaliar0) < 3:\n",
    "#                 # print('CASO_05.1: 1 < Sobrenome < 3 fica em minúsculas')\n",
    "#                 sbrn0          = avaliar0.lower()\n",
    "#             else:\n",
    "#                 # print('CASO_05.2: Sobrenome de tamanho 1 ou maior que 3 fica em maiúsculas')\n",
    "#                 sbrn0          = avaliar0.title()\n",
    "#             # print('sbrn0:',sbrn0, len(sbrn0))\n",
    "            \n",
    "#             try:\n",
    "#                 avaliar1=div[0].split(' ')[1].strip()\n",
    "#                 # print('avaliar0',avaliar0)\n",
    "#                 # print('avaliar1',avaliar1)\n",
    "#                 if 1 < len(avaliar1) <=3:\n",
    "#                     sbrn1     = avaliar1.lower()\n",
    "#                 else:\n",
    "#                     sbrn1     = avaliar1.title()\n",
    "#                 # print('sbrn1:',sbrn1, len(sbrn1))\n",
    "\n",
    "#             except:\n",
    "#                 pass\n",
    "\n",
    "#             if div != []:\n",
    "#                 # print('CASO_05.3: Caso haja divisão por vírgulas na string')\n",
    "#                 try:\n",
    "#                     div_espaco     = div[1].split(' ')\n",
    "#                 except:\n",
    "#                     div_espaco     = div[0].split(' ')\n",
    "#                 sobrenome      = div_espaco[0].strip().upper()\n",
    "#                 try:\n",
    "#                     primeiro_nome  = div_espaco[1].title().strip()\n",
    "#                 except:\n",
    "#                     primeiro_nome  = div_espaco[0].title().strip()\n",
    "#                 if len(sbrn0) == 1:\n",
    "#                     # print('CASO_05.3a: Avalia primeiro sobrenome de tamanho 1')\n",
    "#                     # print('Vai pros nomes:',str(sbrn0).title())\n",
    "#                     nomes_meio = nomes_meio+str(' '+sbrn0.title())\n",
    "#                     # print('   NomesMeio:',nomes_meio)\n",
    "\n",
    "#                 elif 1 < len(sbrn0) <= 3:\n",
    "#                     # print('CASO_05.3b: Avalia primeiro sobrenome 1< tamanho <=3')\n",
    "#                     # print('Vão pros nomes sbrn0:',sbrn0, 'e sbrn1:',sbrn1)\n",
    "\n",
    "#                     div_tresconsoantes = letras_tresconsnts.findall(sobrenome)\n",
    "#                     if div_tresconsoantes != []:\n",
    "#                         # print('CASO_05.4: Três consoantes como sobrenome')\n",
    "#                         for letra in sobrenome:\n",
    "#                             nomes.append(letra)\n",
    "\n",
    "#                         if len(sobrenome) >2:\n",
    "#                             sobrenome=nomes[0]\n",
    "#                         else:\n",
    "#                             sobrenome=nomes[1]\n",
    "#                         nomes.remove(sobrenome)\n",
    "#                         primeiro_nome=nomes[0]\n",
    "#                         nomes_meio=' '.join([str for str in nomes[1:]]).strip()\n",
    "#                         nome_completo=sobrenome.upper()+', '+nomes_meio                \n",
    "                    \n",
    "#                     try:                       \n",
    "#                         # print(' 05.3b    Lista de Nomes:',nomes_meio)\n",
    "#                         nomes_meio=nomes_meio.replace(sbrn0,'')\n",
    "#                         # print(' 05.3b ReplaceSobrenome0:',nomes_meio)\n",
    "#                         nomes_meio=nomes_meio.replace(sbrn1,'')\n",
    "#                         # print(' 05.3b ReplaceSobrenome1:',nomes_meio)\n",
    "#                     except Exception as e:\n",
    "#                         # print('   Erro ReplaceSobrenome:',e)\n",
    "#                         pass\n",
    "#                     try:\n",
    "#                         nomes_meio.replace(primeiro_nome.title(),'')\n",
    "#                         nomes_meio.replace(primeiro_nome.lower(),'')\n",
    "#                         nomes_meio.replace(primeiro_nome,'')\n",
    "#                         # print(' 05.3b Replace PrimNome:',nomes_meio)\n",
    "#                     except Exception as e:\n",
    "#                         print('Erro no try PrimeiroNome:',e)\n",
    "#                         pass\n",
    "#                     nomes_meio = nomes_meio.replace(sobrenome,'')\n",
    "#                     try:\n",
    "#                         for n,i in enumerate(avaliar1):\n",
    "#                             nomes.append(i.upper())\n",
    "#                             sbrn1     = avaliar1[0]\n",
    "#                         else:\n",
    "#                             sbrn1     = avaliar1.title()\n",
    "#                         # print('sbrn1:',sbrn1, len(sbrn1))\n",
    "#                         nomes_meio = nomes_meio+str(' '+sbrn0)+str(' '+sbrn1)\n",
    "#                     except:\n",
    "#                         nomes_meio = nomes_meio+str(' '+sbrn0)\n",
    "#                     nomes      = nomes_meio.strip().strip(',').split(' ')\n",
    "#                     # print(' 05.3b NomesMeio:',nomes_meio)\n",
    "#                     # print(' 05.3b     Nomes:',nome)\n",
    "\n",
    "#                 else:\n",
    "#                     # print('CASO_05.3c: Avalia primeiro sobrenome >3')\n",
    "#                     nomes_meio = nomes_meio+str(' '+div[0].strip().title())\n",
    "#                     nomes      = nomes_meio.strip().split(' ')\n",
    "#                     # print(' 05.3c NomesMeio:',nomes_meio)\n",
    "#                     # print(' 05.3c     Nomes:',nomes)\n",
    "\n",
    "#                 nomes_meio=nomes_meio.replace(sobrenome,'').replace(',','').strip()\n",
    "#                 nomes_meio=nomes_meio.replace(primeiro_nome,'').strip()\n",
    "\n",
    "#             # print('Ao final do caso 05')\n",
    "#             # print('    Sobrenome com vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#             # print('Primeiro nome com vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#             # print('Nomes do meio com vírgula:',nomes, len(nomes),'nomes')\n",
    "    \n",
    "#     if sobrenome != '' and primeiro_nome !='':\n",
    "#         nome_completo=sobrenome.upper().replace(',','')+', '+primeiro_nome.replace(',','')+' '+nomes_meio.replace(sobrenome,'').replace(',','')\n",
    "#     elif sobrenome != '':\n",
    "#         nome_completo=sobrenome.upper().replace(',','')+', '+nomes_meio.replace(sobrenome,'').replace(',','')\n",
    "#     else:\n",
    "#         nome_completo=sobrenome.upper()\n",
    "    \n",
    "# #     print('Após ajustes finais')\n",
    "# #     print('     Sobrenome:',sobrenome)\n",
    "# #     print(' Primeiro Nome:',primeiro_nome)\n",
    "# #     print('         Nomes:',nomes)\n",
    "# #     print('     NomesMeio:',nomes_meio)        \n",
    "        \n",
    "# #     print('                Resultado:',nome_completo)\n",
    "    \n",
    "#     return nome_completo.strip()\n",
    "\n",
    "\n",
    "\n",
    "# def padronizar_titulo(titulo_bruto):\n",
    "#     '''\n",
    "#     Retira acentos, expressão (Org.) e espaços vazios do título da publicação\n",
    "#     Autor: Marcos Aires (Fev.2022)\n",
    "#     '''\n",
    "#     import re\n",
    "#     import unicodedata\n",
    "    \n",
    "#     ## Retirar caracteres não unicode\n",
    "#     string = ''.join(ch for ch in unicodedata.normalize('NFKD', titulo_bruto) if not unicodedata.combining(ch))\n",
    "#     string = string.replace('(Org)','').replace('(Org.)','').replace('(Org).','').replace('.',' ').replace('-',' ').replace('\\'',' ').lower()\n",
    "    \n",
    "#     substitui_iniciais=[('rl,', 'r l,'), ('hs,', 'h s,'), ('gc,', 'g c,'), ('sf,', 's f,'), ('fo,', 'f o,'), (' oa,', ' o a,'), ('mss,', 'm s s,'), \n",
    "#                         ('lagares, ma', 'lagares, m a'), ('cota, gf', 'cota, g f'), ('cota gf,', 'cota, g f,'), ('diotaiut,', 'diotaiuti,'), ('grenfell, r f q','queiroz, rafaella fortini grenfell')]\n",
    "#     for i in substitui_iniciais:\n",
    "#         string = string.replace(i[0], i[1])\n",
    "    \n",
    "#     ## Retirar preposições\n",
    "#     preposicoes = ['da', 'de', 'do', 'das', 'dos']\n",
    "#     partes_string = string.split(' ')\n",
    "#     string = ' '.join(x for x in partes_string if x.lower() not in preposicoes)\n",
    "    \n",
    "#     titulo_padronizado = string.strip().strip('\"')\n",
    "    \n",
    "#     return titulo_padronizado\n",
    "\n",
    "\n",
    "\n",
    "# def iniciais_nome(linha_texto):\n",
    "#     '''\n",
    "#     Função para retornar sobrenome+iniciais das partes de nome, na forma: SOBRENOME, X Y Z\n",
    "#      Recebe: String com nome\n",
    "#     Retorna: Tupla com nome e sua versão padronizada em sobrenome+agnome em maiúsculas, seguida de vírgula e das iniciais das demais partes de nome\n",
    "#       Autor: Marcos Aires (Mar.2022)\n",
    "#     '''\n",
    "#     import unicodedata\n",
    "#     import re\n",
    "#     # print('               Analisando:',linha_texto)\n",
    "    \n",
    "#     ## Retirar caracteres não unicode\n",
    "#     string = ''.join(ch for ch in unicodedata.normalize('NFKD', linha_texto) if not unicodedata.combining(ch))\n",
    "#     string = string.replace('(Org)','').replace('(Org.)','').replace('(Org).','').replace('.','')\n",
    "    \n",
    "#     ## Retirar preposições\n",
    "#     preposicoes   = ['da','de','do','das','dos']\n",
    "#     partes_string = string.split(' ')\n",
    "#     string = ' '.join(x for x in partes_string if x.lower() not in preposicoes)\n",
    "        \n",
    "#     ## Expressões regulares para encontrar padrões de divisão de nomes de autores\n",
    "#     sobrenome_inicio   = re.compile(r'^[A-ZÀ-ú-a-z]+,')                 # Sequência de letras maiúsculas no início da string\n",
    "#     sobrenome_composto = re.compile(r'^[A-ZÀ-ú-a-z]+[ ][A-ZÀ-ú-a-z]+,') # Duas sequências de letras no início da string, separadas por espaço, seguidas por vírgula\n",
    "#     letra_abrevponto   = re.compile(r'^[A-Z][.]')                       # Uma letra maiúscula no início da string, seguida por ponto\n",
    "#     letra_abrevespaco  = re.compile(r'^[A-Z][ ]')                       # Uma letra maiúscula no início da string, seguida por espaço\n",
    "#     letras_dobradas    = re.compile(r'[A-Z]{2}')                        # Duas letras maiúsculas juntas no início da string, seguida por espaço\n",
    "#     letras_dobradasini = re.compile(r'[A-Z]{2}[ ]')                     # Duas letras maiúsculas juntas no início da string, seguida por espaço\n",
    "#     letras_dobradasfim = re.compile(r'[ ][A-Z]{2}')                     # Duas letras maiúsculas juntas no final da string, precedida por espaço\n",
    "        \n",
    "#     nomes=[]\n",
    "#     agnomes       = ['NETO','JUNIOR','FILHO','SEGUNDO','TERCEIRO', 'SOBRINHO']\n",
    "#     nome_completo = ''\n",
    "    \n",
    "#     ## Ajustar lista de termos, identificar sobrenomes compostos e ajustar sobrenome com ou sem presença de vírgula\n",
    "#     div_sobrenome      = sobrenome_inicio.findall(string)\n",
    "#     div_sbrcomposto    = sobrenome_composto.findall(string)\n",
    "    \n",
    "#     ## Caso haja vírgulas na string, tratar sobrenomes e sobrenomes compostos\n",
    "#     if div_sobrenome != [] or div_sbrcomposto != []:\n",
    "#         div   = string.split(', ')\n",
    "#         sobrenome     = div[0].strip().upper()\n",
    "#         try:\n",
    "#             div_espaco    = div[1].split(' ')\n",
    "#         except:\n",
    "#             div_espaco  = ['']\n",
    "#         primeiro      = div_espaco[0].strip('.')\n",
    "        \n",
    "#         ## Caso primeiro nome sejam somente duas letras maiúsculas juntas, trata-se de duas iniciais\n",
    "#         if len(primeiro)==2:\n",
    "#             primeiro_nome=primeiro[0].strip()\n",
    "#             nomes.append(primeiro[1].strip())\n",
    "#         else:\n",
    "#             primeiro_nome = div_espaco[0].strip().title()\n",
    "        \n",
    "#         ## Montagem da lista de nomes do meio\n",
    "#         for nome in div_espaco:\n",
    "#             if nome not in nomes and nome.lower()!=primeiro_nome.lower() and nome.lower() not in primeiro_nome.lower() and nome!=sobrenome:   \n",
    "#                 # print(nome, len(nome))\n",
    "                \n",
    "#                 ## Avaliar se é abreviatura seguida de ponto e remover o ponto\n",
    "#                 if len(nome)<=2 and nome.lower() not in preposicoes:\n",
    "#                     for inicial in nome:\n",
    "#                         # print(inicial)\n",
    "#                         if inicial not in nomes and inicial not in primeiro_nome:\n",
    "#                             nomes.append(inicial.replace('.','').strip().title())\n",
    "#                 else:\n",
    "#                     if nome not in nomes and nome!=primeiro_nome and nome!=sobrenome and nome!='':\n",
    "#                         if nome.lower() in preposicoes:\n",
    "#                             nomes.append(nome.replace('.','').strip().lower())\n",
    "#                         else:\n",
    "#                             nomes.append(nome.replace('.','').strip().title())\n",
    "#                         # print(nome,'|',primeiro_nome)\n",
    "                        \n",
    "#         ## Caso haja sobrenome composto que não esteja nos agnomes considerar somente primeira parte como sobrenome\n",
    "#         if div_sbrcomposto !=[] and sobrenome.split(' ')[1] not in agnomes:\n",
    "#             # print(div_sbrcomposto)\n",
    "#             # print('Sobrenome composto:',sobrenome)\n",
    "#             nomes.append(sobrenome.split(' ')[1].title())\n",
    "#             sobrenome = sobrenome.split(' ')[0].upper()\n",
    "#             # print('Sobrenome:',sobrenome.split(' '))\n",
    "#             for i in nomes:\n",
    "#                 if i.lower() in sobrenome.lower():\n",
    "#                     nomes.remove(i)\n",
    "#             # print('Nomes do meio:',nomes)\n",
    "        \n",
    "#         # print('    Sobrenome com vírgula:',sobrenome, len(sobrenome),'letras')\n",
    "#         # print('Primeiro nome com vírgula:',primeiro_nome, len(primeiro_nome),'letras')\n",
    "#         # print('Nomes do meio com vírgula:',nomes, len(nomes),'nomes')\n",
    "        \n",
    "#     ## Caso não haja vírgulas na string considera sobrenome o último nome da string dividida com espaço vazio\n",
    "#     else:\n",
    "#         try:\n",
    "#             div       = string.split(' ')\n",
    "#             if div[-2] in agnomes:\n",
    "#                 sobrenome = div[-2].upper()+' '+div[-1].strip().upper()\n",
    "#                 for i in nomes[1:-2]:\n",
    "#                     if i not in sobrenome and i not in preposicoes:\n",
    "#                         nomes.append(i.strip().title())\n",
    "#                     if i in preposicoes:\n",
    "#                         nomes.append(i.strip().lower())\n",
    "#             else:\n",
    "#                 sobrenome = div[-1].strip().upper()\n",
    "#                 for i in div[1:-1]:\n",
    "#                     if i not in sobrenome and i not in preposicoes:\n",
    "#                         nomes.append(i.strip().title())\n",
    "#                     if i in preposicoes:\n",
    "#                         nomes.append(i.strip().lower())\n",
    "#         except:\n",
    "#             sobrenome = div[-1].strip().upper()\n",
    "#             for i in div[1:-1]:\n",
    "#                     if i not in sobrenome and i not in preposicoes:\n",
    "#                         nomes.append(i.strip().title())\n",
    "#                     if i in preposicoes:\n",
    "#                         nomes.append(i.strip().lower())\n",
    "            \n",
    "#         if sobrenome.lower() != div[0].strip().lower():\n",
    "#             primeiro_nome=div[0].strip().title()\n",
    "#         else:\n",
    "#             primeiro_nome=''\n",
    "        \n",
    "#         # print('    Sobrenome sem vírgula:',sobrenome)\n",
    "#         # print('Primeiro nome sem vírgula:',primeiro_nome)\n",
    "#         # print('Nomes do meio sem vírgula:',nomes)\n",
    "    \n",
    "#     # Encontrar e tratar como abreviaturas termos com apenas uma ou duas letras iniciais juntas, com ou sem ponto\n",
    "#     for j in nomes:\n",
    "#         # Procura padrões com expressões regulares na string\n",
    "#         div_sobrenome      = sobrenome_inicio.findall(j)\n",
    "#         div_sbrcomposto    = sobrenome_composto.findall(j)\n",
    "#         div_abrevponto     = letra_abrevponto.findall(j)\n",
    "#         div_abrevespaco    = letra_abrevespaco.findall(j)\n",
    "#         div_ltrdobradasini = letras_dobradasini.findall(j)\n",
    "#         div_ltrdobradasfim = letras_dobradasfim.findall(j)\n",
    "#         div_ltrdobradas    = letras_dobradas.findall(j)\n",
    "#         tamanho=len(j)\n",
    "#         # print('\\n', div_ltrdobradasini, div_ltrdobradasfim, tamanho, 'em:',j,len(j))\n",
    "        \n",
    "#         #caso houver abreviatura com uma letra em maiúscula nos nomes\n",
    "#         if div_abrevponto !=[] or tamanho==1:\n",
    "#             cada_nome = j.replace('.','').strip()\n",
    "#             if cada_nome not in nomes and cada_nome != sobrenome and nome != primeiro_nome:\n",
    "#                 nomes.append(cada_nome)\n",
    "        \n",
    "#         #caso houver duas inicias juntas em maiúsculas\n",
    "#         elif div_ltrdobradasini !=[] or div_ltrdobradasfim !=[] or div_ltrdobradas !=[] :\n",
    "#             for letra in j:\n",
    "#                 if letra not in nomes and letra != sobrenome and letra != primeiro_nome:\n",
    "#                     nomes.append(letra)\n",
    "        \n",
    "#         #caso haja agnomes ao sobrenome\n",
    "#         elif sobrenome in agnomes:\n",
    "#             sobrenome = nomes[-1].upper()+' '+sobrenome\n",
    "#             # print(sobrenome.split(' '))\n",
    "#             # print('Sobrenome composto:',sobrenome)\n",
    "#             for i in nomes:\n",
    "#                 if i.lower() in sobrenome.lower():\n",
    "#                     nomes.remove(i)\n",
    "#             # print('Nomes do meio:',nomes)\n",
    "            \n",
    "#         else:\n",
    "#             if j not in nomes and j not in sobrenome and j != primeiro_nome:\n",
    "#                 nomes.append(j)\n",
    "    \n",
    "#     nomes_meio=' '.join([str[0] for str in nomes]).strip()\n",
    "#     # print('Qte nomes do meio',len(nomes),nomes)\n",
    "#     if sobrenome != '' and primeiro_nome !='':\n",
    "#         sobrenome_iniciais = sobrenome+', '+primeiro_nome[0]+' '+nomes_meio\n",
    "#     elif sobrenome != '':\n",
    "#         sobrenome_iniciais = sobrenome\n",
    "    \n",
    "#     return sobrenome_iniciais.strip()\n",
    "\n",
    "\n",
    "# ## Agregar aprendizado supervisionado humano à medida que forem sendo identificados erros na situação atual\n",
    "# lista_extra = [\n",
    "#                 # ('ALBUQUERQUE, Adriano B', 'ALBUQUERQUE, Adriano Bessa'),\n",
    "#                 # ('ALBUQUERQUE, Adriano', 'ALBUQUERQUE, Adriano Bessa'),\n",
    "#                 # ('COELHO, Andre L V', 'COELHO, Andre Luis Vasconcelos'),\n",
    "#                 # ('DUARTE, Joao B F', 'DUARTE, Joao Batista Furlan'),\n",
    "#                 # ('FILHO, Raimir H','HOLANDA FILHO, Raimir'),\n",
    "#                 # ('FILHO, Raimir','HOLANDA FILHO, Raimir'),\n",
    "#                 # ('FORMIGO, A','FORMICO, Maria Andreia Rodrigues'),\n",
    "#                 # ('FORMICO, A','FORMICO, Maria Andreia Rodrigues'),\n",
    "#                 # ('FURLAN, J B D', 'FURLAN, Joao Batista Duarte'),\n",
    "#                 # ('FURTADO, Elizabeth', 'FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 # ('FURTADO, Elizabeth S', 'FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 # ('FURTADO, Elizabeth Sucupira','FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 # ('FURTADO, M E S', 'FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 # ('FURTADO, Vasco', 'FURTADO, Joao Jose Vasco Peixoto'),\n",
    "#                 # ('FURTADO, J P', 'FURTADO, Joao Jose Vasco Peixoto'),\n",
    "#                 # ('FURTADO, J V P', 'FURTADO, Joao Jose Vasco Peixoto'),\n",
    "#                 # ('FURTADO, Vasco', 'FURTADO, Joao Jose Vasco Peixoto'),\n",
    "#                 # ('FURTADO, Elizabeth','FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 # ('HOLANDA, Raimir', 'HOLANDA FILHO, Raimir'),\n",
    "#                 # ('LEITE, G S', 'LEITE, Gleidson Sobreira'),\n",
    "#                 # ('PEQUENO, T H C', 'PEQUENO, Tarcisio Haroldo Cavalcante'),\n",
    "#                 # ('PEQUENO, Tarcisio','PEQUENO, Tarcisio Haroldo Cavalcante'),\n",
    "#                 # ('PEQUENO, Tarcisio Cavalcante', 'PEQUENO, Tarcisio Haroldo Cavalcante'),\n",
    "#                 # ('PINHEIRO, Placido R', 'PINHEIRO, Placido Rogerio'),\n",
    "#                 # ('PINHEIRO, Vladia', 'PINHEIRO, Vladia Celia Monteiro'),\n",
    "#                 # ('RODRIGUES, M A F', 'RODRIGUES, Maria Andreia Formico'),\n",
    "#                 # ('RODRIGUES, Andreia', 'RODRIGUES, Maria Andreia Formico'),\n",
    "#                 # ('JOAO, Batista F Duarte,', 'FURLAN, Joao Batista Duarte'),\n",
    "#                 # ('MACEDO, Antonio Roberto M de', 'MACEDO, Antonio Roberto Menescal de'),\n",
    "#                 # ('MACEDO, D V', 'MACEDO, Daniel Valente'),\n",
    "#                 # ('MENDONCA, Nabor C', 'MENDONCA, Nabor das Chagas'),\n",
    "#                 # ('PEQUENO, Tarcisio', 'PEQUENO, Tarcisio Haroldo Cavalcante'),\n",
    "#                 # ('PEQUENO, Tarcisio H', 'PEQUENO, Tarcisio Haroldo Cavalcante'),\n",
    "#                 # ('PINHEIRO, Mirian C D', 'PINHEIRO, Miriam Caliope Dantas'),\n",
    "#                 # ('PINHEIRO, Mirian Caliope Dantas', 'PINHEIRO, Miriam Caliope Dantas'),\n",
    "#                 # ('PINHEIRO, P G C D', 'PINHEIRO, Pedro Gabriel Caliope Dantas'),\n",
    "#                 # ('PINHEIRO, Pedro G C', 'PINHEIRO, Pedro Gabriel Caliope Dantas'),\n",
    "#                 # ('PINHEIRO, Placido R', 'PINHEIRO, Placido Rogerio'),\n",
    "#                 # ('PINHEIRO, Vladia', 'PINHEIRO, Vladia Celia Monteiro'),\n",
    "#                 # ('ROGERIO, Placido Pinheiro', 'PINHEIRO, Placido Rogerio'),\n",
    "#                 # ('REBOUCRAS FILHO, Pedro', 'REBOUCAS FILHO, Pedro Pedrosa'),\n",
    "#                 # ('SAMPAIO, A', 'SAMPAIO, Americo Tadeu Falcone'),\n",
    "#                 # ('SAMPAIO, Americo', 'SAMPAIO, Americo Tadeu Falcone'),\n",
    "#                 # ('SAMPAIO, Americo Falcone', 'SAMPAIO, Americo Tadeu Falcone'),\n",
    "#                 # ('SUCUPIRA, Elizabeth Furtado','FURTADO, Maria Elizabeth Sucupira'),\n",
    "#                 ]\n",
    "\n",
    "\n",
    "# def converter_lista_set(lista):\n",
    "#     set1 = set(lista)\n",
    "#     return set1\n",
    "\n",
    "\n",
    "# def jaccard_similarity(set1, set2):\n",
    "#     '''\n",
    "#     Recebe dois conjuntos como entradas e retorna a similaridade Jaccard entre eles. \n",
    "#     1. calcula a interseção dos dois conjuntos usando a função de interseção e, \n",
    "#     2. calcula a união dos dois conjuntos usando a função de união. \n",
    "#     3. retorna a razão entre o comprimento da interseção e o comprimento da união, que é a similaridade de Jaccard.\n",
    "#     '''\n",
    "#     intersection = set1.intersection(set2)\n",
    "#     union        = set1.union(set2)\n",
    "#     return len(intersection) / len(union)\n",
    "\n",
    "\n",
    "# def similares(lista_autores, lista_grupo, limite_jarowinkler, distancia_levenshtein, lista_extra):\n",
    "#     \"\"\"Função para aplicar padronização no nome de autor da lista de pesquisadores e buscar similaridade na lista de coautores\n",
    "#      Recebe: Lista de pesquisadores do grupo em análise gerada pela lista de nomes dos coautores das publicações em análise\n",
    "#     Utiliza: get_jaro_distance(), editdistance()\n",
    "#     Retorna: Lista de autores com fusão de nomes cuja similaridade esteja dentro dos limites definidos nesta função\n",
    "#       Autor: Marcos Aires (Fev.2022)\n",
    "      \n",
    "#     Refazer: Inserir crítica de, mantendo sequência ordem alfabética, retornar no final nome mais extenso em caso de similaridade;\n",
    "#     \"\"\"\n",
    "#     from pyjarowinkler.distance import get_jaro_distance\n",
    "#     from IPython.display import clear_output\n",
    "#     import editdistance\n",
    "#     import numpy as np\n",
    "#     import time\n",
    "    \n",
    "#     t0=time.time()\n",
    "    \n",
    "#     # limite_jarowinkler=0.85\n",
    "#     # distancia_levenshtein=6\n",
    "#     similares_jwl=[]\n",
    "#     similares_regras=[]\n",
    "#     similares=[]\n",
    "#     tempos=[]\n",
    "    \n",
    "#     count=0\n",
    "#     t1=time.time()\n",
    "#     for i in lista_autores:\n",
    "#         count+=1\n",
    "#         if count > 0:\n",
    "#             tp=time.time()-t1\n",
    "#             tmed=tp/count*2\n",
    "#             tempos.append(tp)\n",
    "#         # print(\"Analisar similaridades com: \", nome_padronizado)\n",
    "        \n",
    "#         count1=0\n",
    "#         for nome in lista_autores:\n",
    "#             if count1 > 0:\n",
    "#                 resta=len(lista_autores)-count\n",
    "#                 print(f'Analisando {count1:3}/{len(lista_autores)} resta analisar {resta:3} nomes. Previsão de término em {np.round(tmed*resta/60,1)} minutos')\n",
    "#             else:\n",
    "#                 print(f'Analisando {count1:3}/{len(lista_autores)} resta analisar {len(lista_autores)-count1} nomes.')\n",
    "            \n",
    "#             t2=time.time()\n",
    "#             count1+=1            \n",
    "\n",
    "#             try:\n",
    "#                 similaridade_jarowinkler = get_jaro_distance(i, nome)\n",
    "#                 print(f'{i:40} | {nome:40} | Jaro-Winkler: {np.round(similaridade_jarowinkler,2):4} Levenshtein: {editdistance.eval(i, nome)}')\n",
    "#                 similaridade_levenshtein = editdistance.eval(i, nome)\n",
    "\n",
    "#                 # inferir similaridade para nomes que estejam acima do limite ponderado definido, mas não idênticos e não muito distantes em edição\n",
    "#                 if  similaridade_jarowinkler > limite_jarowinkler and similaridade_jarowinkler!=1 and similaridade_levenshtein < distancia_levenshtein:\n",
    "#                     # Crítica no nome mais extenso como destino no par (origem, destino)\n",
    "                    \n",
    "#                     similares_jwl.append((i,nome))\n",
    "\n",
    "#             except:\n",
    "#                 pass\n",
    "\n",
    "#             clear_output(wait=True)\n",
    "    \n",
    "#     # Conjunto de regras de validação de similaridade\n",
    "#     # Monta uma lista de nomes a serem retirados antes de montar a lista de troca\n",
    "#     trocar=[]\n",
    "#     retirar=[]\n",
    "#     for i in similares_jwl:\n",
    "#         sobrenome_i = i[0].split(',')[0]\n",
    "#         sobrenome_j = i[1].split(',')[0]\n",
    "\n",
    "#         try:\n",
    "#             iniciais_i  = iniciais_nome(i[0]).split(',')[1].strip()\n",
    "#         except:\n",
    "#             iniciais_i  = ''\n",
    "\n",
    "#         try:\n",
    "#             iniciais_j  = iniciais_nome(i[1]).split(',')[1].strip()\n",
    "#         except:\n",
    "#             iniciais_j  = ''\n",
    "\n",
    "#         try:\n",
    "#             primnome_i = i[0].split(',')[1].strip().split(' ')[0].strip()\n",
    "#         except:\n",
    "#             primnome_i = ''\n",
    "\n",
    "#         try:\n",
    "#             primnome_j = i[1].split(',')[1].strip().split(' ')[0].strip()\n",
    "#         except:\n",
    "#             primnome_j = ''    \n",
    "\n",
    "#         try:\n",
    "#             inicial_i = i[0].split(',')[1].strip()[0]\n",
    "#         except:\n",
    "#             inicial_i = ''\n",
    "\n",
    "#         try:\n",
    "#             resto_i   = i[0].split(',')[1].strip().split(' ')[0][1:]\n",
    "#         except:\n",
    "#             resto_i   = ''\n",
    "\n",
    "#         try:\n",
    "#             inicial_j = i[1].split(',')[1].strip()[0]\n",
    "#         except:\n",
    "#             inicial_j = ''\n",
    "\n",
    "#         try:\n",
    "#             resto_j   = i[1].split(',')[1].strip().split(' ')[0][1:]\n",
    "#         except:\n",
    "#             resto_j = ''\n",
    "\n",
    "#         # Se a distância de edição entre os sobrenomes\n",
    "#         if editdistance.eval(sobrenome_i, sobrenome_j) > 2 or inicial_i!=inicial_j:\n",
    "#             retirar.append(i)\n",
    "#         else:\n",
    "#             if primnome_i!=primnome_j and len(primnome_i)>1:\n",
    "#                 retirar.append(i)\n",
    "#             if primnome_i!=primnome_j and len(primnome_i)>1 and len(primnome_j)>1:\n",
    "#                 retirar.append(i)\n",
    "#             if resto_i!=resto_j and resto_i!='':\n",
    "#                 retirar.append(i)\n",
    "#             if len(i[1]) < len(i[0]):\n",
    "#                 retirar.append(i)\n",
    "#             if len(iniciais_i) != len(iniciais_j):\n",
    "#                 retirar.append(i)\n",
    "\n",
    "#     for i in similares_jwl:\n",
    "#         if i not in retirar:\n",
    "#             trocar.append(i)\n",
    "\n",
    "#         if iniciais_nome(i[0]) in iniciais_nome(i[1]) and len(i[0]) < len(i[1]):\n",
    "#             trocar.append(i)\n",
    "\n",
    "#         if iniciais_nome(i[0]) == iniciais_nome(i[1]) and len(i[0]) < len(i[1]):\n",
    "#              trocar.append(i)\n",
    "    \n",
    "#     trocar=trocar+lista_extra\n",
    "#     trocar.sort()\n",
    "    \n",
    "#     return trocar\n",
    "\n",
    "\n",
    "\n",
    "# def extrair_variantes(df_dadosgrupo):\n",
    "#     ''' Utiliza campo de Nome em Citações do currículo como filtro para obter variantes do nome de cada membro\n",
    "#      Recebe: Dataframe com os dados brutos do grupo de pesquisa agrupados; lista de nomes de pesquisadores de interesse\n",
    "#     Retorna: Lista de tuplas com pares a serem trocados da variante pelo nome padronizado na forma (origem, destino)\n",
    "#     '''\n",
    "#     filtro1   = 'Nome'\n",
    "#     lista_nomes = df_dadosgrupo[(df_dadosgrupo.ROTULOS == filtro1)]['CONTEUDOS'].values\n",
    "\n",
    "#     variantes=[]\n",
    "#     filtro='Nome em citações bibliográficas'\n",
    "#     variantes=df_dadosgrupo[(df_dadosgrupo.ROTULOS == filtro)]['CONTEUDOS'].to_list()\n",
    "\n",
    "#     trocar=[]\n",
    "#     for j in range(len(variantes)):\n",
    "#         padrao_destino = padronizar_nome(lista_nomes[j])\n",
    "#         trocar.append((lista_nomes[j], padrao_destino))\n",
    "#         for k in variantes[j]:\n",
    "#             padrao_origem = padronizar_nome(k)\n",
    "#             trocar.append((k, padrao_destino))\n",
    "#             trocar.append((padrao_origem, padrao_destino))\n",
    "    \n",
    "#     return trocar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67fbfc46",
   "metadata": {},
   "source": [
    "    Apurar colaborações docente/discente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d78c1e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def converter_lista_set(lista):\n",
    "#     set1 = set(lista)\n",
    "#     return set1\n",
    "\n",
    "# def montardf_producao(lista_csv):\n",
    "#     print(f'{len(lista_csv):02} nomes a extrair')\n",
    "#     df_public=pd.DataFrame()\n",
    "#     for nome_csv in lista_csv:\n",
    "#         if 'colaboradores' in nome_csv.lower():\n",
    "#             tipo='colaboradores'\n",
    "#         else:\n",
    "#             tipo='permanentes'\n",
    "        \n",
    "#         df_pub = pd.read_csv(pathcsv+nome_csv)\n",
    "#         print(len(df_pub.index))\n",
    "#         print(df_pub.keys())\n",
    "\n",
    "#         pat='\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'\n",
    "#         df_temp1 = df_pub.Data.str.split(pat=pat,expand=True)\n",
    "#         df_temp1.columns = (['TITULO','RevAut'])\n",
    "\n",
    "#         pat1='\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'\n",
    "#         df_temp2 = df_temp1.RevAut.str.split(pat=pat1,expand=True)\n",
    "#         df_temp2.columns = (['REVISTA','AUTORES'])\n",
    "\n",
    "#         df_temp0 = df_pub.drop(['Data'], axis=1)\n",
    "#         df_pub=df_temp0.merge(df_temp1['TITULO'],left_index=True,right_index=True)\n",
    "#         df_pub=df_pub.merge(df_temp2,left_index=True,right_index=True)\n",
    "#         try:\n",
    "#             df_pub.drop(['Issn','Natureza'], axis=1, inplace=True)\n",
    "#         except:\n",
    "#             pass\n",
    "#         try:\n",
    "#             df_pub.drop(['Tipo','Idioma'], axis=1, inplace=True)\n",
    "#         except:\n",
    "#             pass\n",
    "\n",
    "#         df_public = pd.concat([df_public, df_pub], ignore_index=True)\n",
    "#         print(len(df_public.index))\n",
    "#         print(df_public.keys())\n",
    "        \n",
    "#     ## Extrai o período com base nos dados\n",
    "#     inicio = min(df_public['Ano'])\n",
    "#     final  = max(df_public['Ano'])\n",
    "    \n",
    "#     total_artigos=len(df_public.index)\n",
    "#     # print(f'{total_artigos:4} publicações de artigos de docentes do programa no período de {inicio} a {final} carregadas...') \n",
    "    \n",
    "#     return df_public\n",
    "\n",
    "# def ler_nomesdocentes():    \n",
    "#     print(pathcsv)\n",
    "#     import os, sys\n",
    "\n",
    "#     lista_csv=[]\n",
    "#     dirs = os.listdir(pathcsv)\n",
    "#     for file in dirs:\n",
    "#         if 'nomes_docentes' in file:\n",
    "#             lista_csv.append(file)\n",
    "#     lista_csv.sort()\n",
    "    \n",
    "#     for i in lista_csv:\n",
    "#         print(i)\n",
    "\n",
    "#     return lista_csv\n",
    "\n",
    "\n",
    "# ## ler arquivo com as orientações para gerar a lista de discentes\n",
    "# def ler_lista_orientacoes():\n",
    "#     try:\n",
    "#         l1='lista_orientadores-discentes.csv'\n",
    "#         df_orientacoes = pd.read_csv(pathcsv+l1, delimiter=';', header=None)\n",
    "        \n",
    "#         lista_orientadores = df_orientacoes.iloc[:,0].unique()\n",
    "#         lista_discentes    = df_orientacoes.iloc[:,1].unique()\n",
    "#         print(f'{len(lista_orientadores):4} orientadores, com {len(lista_discentes)} discentes encontrados')\n",
    "#     except Exception as e:\n",
    "#         print('Erro ao gerar lista de orientações:')\n",
    "#         print(e)\n",
    "#         return df_orientacoes\n",
    "        \n",
    "#     return lista_orientadores, lista_discentes \n",
    "\n",
    "\n",
    "# ## montar um dataframe com nome dos discentes de cada orientador\n",
    "# def montardf_orientacoes():\n",
    "#     try:\n",
    "#         l1='lista_orientadores-discentes.csv'\n",
    "#         df_orientacoes = pd.read_csv(pathcsv+l1, delimiter=';', header=None)\n",
    "#         df_orientacoes.columns=['ORIENTADOR','DISCENTE']\n",
    "        \n",
    "#     except Exception as e:\n",
    "#         print('Erro ao dividir dataframe de orientações:')\n",
    "#         print(e)\n",
    "#         return\n",
    "        \n",
    "#     return df_orientacoes\n",
    "\n",
    "\n",
    "\n",
    "# def montardf_docentes_permanentes_colaboradores():\n",
    "#     try:\n",
    "#         l1='lista_docentes_colaboradores.csv'\n",
    "#         l2='lista_docentes_permanentes.csv'\n",
    "#         df_docclbr = pd.read_csv(os.path.join(pathcsv,l1), header=None)\n",
    "#         df_docperm = pd.read_csv(os.path.join(pathcsv,l2), header=None)\n",
    "#         df_docentes = pd.concat([df_docperm, df_docclbr], ignore_index=True)\n",
    "#         print(f'{len(df_docentes.index):4} docentes permanentes e colaboradores encontrados')\n",
    "#     except Exception as e:\n",
    "#         print(e)\n",
    "        \n",
    "#     return df_docentes\n",
    "\n",
    "\n",
    "# def jaccard_similarity(set1, set2):\n",
    "#     '''\n",
    "#     Recebe dois conjuntos (sets) como entradas e retorna a similaridade Jaccard entre eles e avalia: \n",
    "#     1. calcula a interseção dos dois conjuntos usando a função de interseção \n",
    "#     2. calcula a união dos dois conjuntos usando a função de união \n",
    "#     3. retorna a razão entre o comprimento da interseção e o comprimento da união, que é a similaridade de Jaccard.\n",
    "#     '''\n",
    "#     intersection = set1.intersection(set2)\n",
    "#     union        = set1.union(set2)\n",
    "#     return len(intersection) / len(union)\n",
    "    \n",
    "# def montardf_docentes(lista_nomes1=False, lista_nomes2=False):\n",
    "#     # print(lista_nomes1)\n",
    "#     # print(lista_nomes2)\n",
    "\n",
    "#     ## Montagem do dataframe de participação docente\n",
    "#     if (lista_nomes1 and lista_nomes2) != False:\n",
    "#         ## Criar dataframe com os nomes do grupo de docentes permanentes\n",
    "#         file_path = os.path.join(pathcsv,'lista_docentes_permanentes.csv')\n",
    "#         df_docentes_permanentes   = pd.read_csv(file_path, header=None)\n",
    "#         # df_docentes_permanentes['GRUPO']='Permanente'\n",
    "#         # try:\n",
    "#         #     df_docentes_permanentes.drop(columns=([1,2]), inplace=True)\n",
    "#         # except:\n",
    "#         #     pass\n",
    "#         # df_docentes_permanentes.columns = ['DOCENTE','GRUPO']\n",
    "#         df_docentes_permanentes.columns = ['DOCENTE','IDLATES','PROGRAMA','GRUPO']\n",
    "\n",
    "#         ## Criar dataframe com os nomes do grupo de docentes colaboradores\n",
    "#         file_path = os.path.join(pathcsv,'lista_docentes_colaboradores.csv')\n",
    "#         df_docentes_colaboradores = pd.read_csv(file_path, header=None)\n",
    "#         # df_docentes_colaboradores['GRUPO']='Colaborador'\n",
    "#         # try:\n",
    "#         #     df_docentes_colaboradores.drop(columns=([1,2]), inplace=True)\n",
    "#         # except:\n",
    "#         #     pass\n",
    "#         df_docentes_colaboradores.columns = ['DOCENTE','IDLATES','PROGRAMA','GRUPO']\n",
    "\n",
    "#         ## Criar um dataframe único com todos grupos de docentes juntos\n",
    "#         df_docentes = pd.concat([df_docentes_permanentes, df_docentes_colaboradores]).reset_index(drop=True)\n",
    "#         return df_docentes\n",
    "\n",
    "#     elif 'permanentes' in lista_nomes1.lower():\n",
    "#         ## Criar dataframe com os nomes do grupo de docentes permanentes\n",
    "#         file_path = os.path.join(pathcsv,lista_nomes1)       \n",
    "#         df_docentes_permanentes   = pd.read_csv(file_path, header=None)\n",
    "#         # df_docentes_permanentes['GRUPO']='Permanente'\n",
    "#         # try:\n",
    "#         #     df_docentes_permanentes.drop(columns=([1,2]), inplace=True)\n",
    "#         # except:\n",
    "#         #     pass\n",
    "#         df_docentes_permanentes.columns = ['DOCENTE','IDLATES','PROGRAMA','GRUPO']\n",
    "#         return df_docentes_permanentes\n",
    "\n",
    "#     elif 'colaboradores' in lista_nomes1.lower():\n",
    "#         ## Criar dataframe com os nomes do grupo de docentes colaboradores\n",
    "#         file_path = os.path.join(pathcsv,lista_nomes1)\n",
    "#         df_docentes_colaboradores = pd.read_csv(file_path, header=None)\n",
    "#         # df_docentes_colaboradores['GRUPO']='Colaborador'\n",
    "#         # try:\n",
    "#         #     df_docentes_colaboradores.drop(columns=([1,2]), inplace=True)\n",
    "#         # except:\n",
    "#         #     pass\n",
    "#         df_docentes_colaboradores.columns = ['DOCENTE','IDLATES','PROGRAMA','GRUPO']\n",
    "#         return df_docentes_colaboradores\n",
    "#     else:\n",
    "#         print('Erro ao montar dataframe de docentes, verifique os nomes de arquivo.')\n",
    "#         return\n",
    "        \n",
    "# def montar_listas(lista_csv, csv_permanentes=None, csv_colaboradores=None):\n",
    "#     if csv_permanentes == None and csv_colaboradores == None:\n",
    "#         csv_permanentes   = 'lista_docentes_permanentes.csv'\n",
    "#         csv_colaboradores = 'lista_docentes_colaboradores.csv'\n",
    "#         print(f'\\nNomes de docentes não informados, utilizando caminho e nomes padrão:')\n",
    "#         print(f'     Docentes   permanentes de {pathcsv}{csv_permanentes}')\n",
    "#         print(f'     Docentes colaboradores de {pathcsv}{csv_colaboradores}')\n",
    "#         try:\n",
    "#             file_path = os.path.join(pathcsv,csv_permanentes)\n",
    "#             df_docperm = pd.read_csv(file_path, header=None)\n",
    "#             file_path = os.path.join(pathcsv,csv_colaboradores)\n",
    "#             df_docclbr = pd.read_csv(file_path, header=None)\n",
    "#             lista_docentes = pd.concat([df_docperm, df_docclbr], ignore_index=True)[0].values\n",
    "#             print(f'{len(lista_docentes):4} docentes permanentes e colaboradores encontrados')\n",
    "#         except Exception as e:\n",
    "#             print(f'Erro ao ler listas de docentes, verificar se os arquivos CSV estão na pasta {pathcsv}')\n",
    "#             print(e)\n",
    "#     elif 'permanentes' in csv_permanentes.lower():\n",
    "#         print(f'\\nArquivo docentes   permanentes informado: {csv_permanentes}')\n",
    "#         try:\n",
    "#             file_path = os.path.join(pathcsv,csv_permanentes)\n",
    "#             lista_docentes = pd.read_csv(file_path, header=None)[0].values\n",
    "#             print(f'{len(lista_docentes)} docentes permanentes encontrados')\n",
    "#         except Exception as e:\n",
    "#             print(e)\n",
    "#     elif 'colaboradores' in csv_permanentes.lower():\n",
    "#         print(f'\\nArquivo docentes colaboradores informado: {csv_colaboradores}')\n",
    "#         try:\n",
    "#             file_path = os.path.join(pathcsv,csv_permanentes)\n",
    "#             lista_docentes = pd.read_csv(file_path, header=None)[0].values\n",
    "#             print(f'{len(lista_docentes)} docentes colaboradores encontrados')\n",
    "#         except Exception as e:\n",
    "#             print(e)    \n",
    "#     else:\n",
    "#         print('Erro ao ler listas de docentes, verificar listas')\n",
    "\n",
    "#     df_prod   = montardf_producao(lista_csv)\n",
    "    \n",
    "#     ## Montar a lista de autores com limpar_nomes remove caracteres, preposições e separa iniciais com espaço\n",
    "#     lista_listas = df_prod['AUTORES'].tolist()\n",
    "#     lista_autores_artigos = []\n",
    "#     for i in lista_listas:\n",
    "#         lista_autores_artigos.append(limpar_nomes(i))\n",
    "    \n",
    "#     ## Ler nomes de discentes e orientadores\n",
    "#     lista_orientadores, lista_discentes = ler_lista_orientacoes()\n",
    "    \n",
    "#     return lista_autores_artigos, lista_docentes, lista_orientadores, lista_discentes\n",
    "\n",
    "# def montardf_participacao_docente_discente(df_prod, dic_nomes_docentes, dic_nomes_discentes):\n",
    "#     ## Montar dataframe de participação docente\n",
    "#     df_participacao_docente = pd.DataFrame(dic_nomes_docentes).T\n",
    "#     df_participacao_docente.columns = ['DOCENTE','INDICES_ARTIGOS']\n",
    "#     df_participacao_docente['AUTORIAS'] = [len(x) for x in df_participacao_docente['INDICES_ARTIGOS']]\n",
    "\n",
    "#     ## Montar dataframe de participação discente\n",
    "#     df_participacao_discente = pd.DataFrame(dic_nomes_discentes).T\n",
    "#     df_participacao_discente.columns = ['DISCENTE','INDICES_ARTIGOS']\n",
    "#     df_participacao_discente['AUTORIAS'] = [len(x) for x in df_participacao_discente['INDICES_ARTIGOS']]\n",
    "\n",
    "#     ## Criar lista com os artigos onde foi encontado nome de algum docente\n",
    "#     artigos_com_docentes=[]\n",
    "#     for m in df_participacao_docente['INDICES_ARTIGOS']:\n",
    "#         for n in m:\n",
    "#             if n not in artigos_com_docentes:\n",
    "#                 artigos_com_docentes.append(n)\n",
    "#     artigos_com_docentes.sort()\n",
    "                \n",
    "#     ## Criar lista com os artigos onde foi encontado nome de algum discente\n",
    "#     artigos_com_discentes=[]\n",
    "#     for m in df_participacao_discente['INDICES_ARTIGOS']:\n",
    "#         for n in m:\n",
    "#             if n not in artigos_com_discentes:\n",
    "#                 artigos_com_discentes.append(n)\n",
    "#     artigos_com_discentes.sort()\n",
    "                \n",
    "        \n",
    "#     ## Criar lista com os artigos onde NÃO foi encontado nome de discente\n",
    "#     lista_semparticipacaodiscente=[]\n",
    "#     for i in range(len(df_prod.index)):\n",
    "#         if i not in artigos_com_discentes and i not in lista_semparticipacaodiscente:\n",
    "#             lista_semparticipacaodiscente.append(i)\n",
    "            \n",
    "#     ## Criar lista com os artigos onde NÃO foi encontado nome de docente\n",
    "#     lista_semparticipacaodocente=[]\n",
    "#     for i in range(len(df_prod.index)):\n",
    "#         if i not in artigos_com_docentes and i not in lista_semparticipacaodocente:\n",
    "#             lista_semparticipacaodocente.append(i)\n",
    "\n",
    "#     ## Apresentar resultados das buscas por nomes de autores docentes e discentes\n",
    "#     lista_titulos = pd.Series(df_prod['TITULO'].values).unique().tolist()\n",
    "#     print(len(lista_titulos),'títulos únicos de artigo encontrados')\n",
    "#     pdoc = np.round(100*len(artigos_com_docentes)/len(df_prod.index),2)\n",
    "#     spdoc = np.round(100*len(lista_semparticipacaodocente)/len(df_prod.index),2)\n",
    "#     print(f'{len(artigos_com_docentes):4} ({pdoc:6}%) artigos com nome de  docente encontrado, faltando {len(lista_semparticipacaodocente):3} ({spdoc:5}%)')\n",
    "\n",
    "#     pdis = np.round(100*len(artigos_com_discentes)/len(df_prod.index),2)\n",
    "#     spdis = np.round(100*len(lista_semparticipacaodiscente)/len(df_prod.index),2)\n",
    "#     print(f'{len(artigos_com_discentes):4} ({pdis:6}%) artigos com nome de discente encontrado, faltando {len(lista_semparticipacaodiscente):3} ({spdis:5}%)')\n",
    "\n",
    "#     return df_participacao_docente, df_participacao_discente, lista_semparticipacaodocente, lista_semparticipacaodiscente"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616ca80e",
   "metadata": {},
   "source": [
    "    Ler arquivos de dados do disco local"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ea93d1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## ler arquivos de publicação de artigos na pasta de arquivos CSV\n",
    "# def ler_artigostodosperiodos():    \n",
    "#     print(pathcsv)\n",
    "#     import os, sys\n",
    "\n",
    "#     lista_csv=[]\n",
    "#     dirs = os.listdir(pathcsv)\n",
    "#     for file in dirs:\n",
    "#         if 'Artigos' in file:\n",
    "#             lista_csv.append(file)\n",
    "#     lista_csv.sort()\n",
    "    \n",
    "#     for i in lista_csv:\n",
    "#         print(i)\n",
    "\n",
    "#     return lista_csv\n",
    "\n",
    "\n",
    "\n",
    "# ## ler arquivos de publicação de de período determinado\n",
    "# def ler_csvptg(inicio=False, final=False, tipo=False, grupo=False):    \n",
    "#     import os, sys\n",
    "\n",
    "#     print(pathcsv)\n",
    "#     lista_csv=[]\n",
    "#     dirs = os.listdir(pathcsv)\n",
    "#     for file in dirs:\n",
    "#         if (str(inicio) or str(final)) == False:\n",
    "#             if tipo.lower() == False:\n",
    "#                 if grupo.lower() == False:\n",
    "#                     lista_csv.append(file)\n",
    "\n",
    "#         elif (str(inicio) and str(final)) in file.lower():\n",
    "#             if unidecode(tipo).lower() in unidecode(file).lower():\n",
    "#                 if unidecode(grupo).lower() in unidecode(file).lower():\n",
    "#                     lista_csv.append(file)\n",
    "#     lista_csv.sort()\n",
    "    \n",
    "#     for i in lista_csv:\n",
    "#         print(i)\n",
    "\n",
    "#     return lista_csv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96f505b4",
   "metadata": {},
   "source": [
    "### Funções para avaliar a PCD e Pontuação de Impacto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2eef1e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def montardf_impacto_docente_discente(df_prod, dic_nomes_docentes, dic_nomes_discentes, inicio, final):\n",
    "#     artigos_com_discentes=[]\n",
    "#     artigos_com_docentes=[]\n",
    "#     lista_semparticipacaodiscente=[]\n",
    "#     lista_semparticipacaodocente=[]\n",
    "\n",
    "#     try:\n",
    "#         ## Montar dataframe de participação docente\n",
    "#         df_impacto_docente = pd.DataFrame(dic_nomes_docentes).T\n",
    "#         df_impacto_docente.columns = ['DOCENTE','INDICES_ARTIGOS','EXTRATOS_QUALIS']\n",
    "#         df_impacto_docente['AUTORIAS'] = [len(x) for x in df_impacto_docente['INDICES_ARTIGOS']]\n",
    "\n",
    "#         ## Criar lista com os artigos onde foi encontado nome de algum docente\n",
    "#         for m in df_impacto_docente['INDICES_ARTIGOS']:\n",
    "#             for n in m:\n",
    "#                 if n not in artigos_com_docentes:\n",
    "#                     artigos_com_docentes.append(n)\n",
    "#         artigos_com_docentes.sort()\n",
    "\n",
    "#         ## Criar lista com os artigos onde NÃO foi encontado nome de docente\n",
    "#         for i in range(len(df_prod.index)):\n",
    "#             if i not in artigos_com_docentes and i not in lista_semparticipacaodocente:\n",
    "#                 lista_semparticipacaodocente.append(i)\n",
    "#     except:\n",
    "#         df_impacto_docente = pd.DataFrame()\n",
    "#         print('Não foi possível encontrar nenhuma ocorrência dos nomes dos docentes com este conjunto de dados')\n",
    "#         pass\n",
    "\n",
    "#     try:\n",
    "#         ## Montar dataframe de participação discente\n",
    "#         df_impacto_discente = pd.DataFrame(dic_nomes_discentes).T\n",
    "#         df_impacto_discente.columns = ['DISCENTE','INDICES_ARTIGOS','EXTRATOS_QUALIS']\n",
    "#         df_impacto_discente['AUTORIAS'] = [len(x) for x in df_impacto_discente['INDICES_ARTIGOS']]\n",
    "\n",
    "#         ## Criar lista com os artigos onde foi encontado nome de algum discente\n",
    "#         for m in df_impacto_discente['INDICES_ARTIGOS']:\n",
    "#             for n in m:\n",
    "#                 if n not in artigos_com_discentes:\n",
    "#                     artigos_com_discentes.append(n)\n",
    "#         artigos_com_discentes.sort()\n",
    "#     except:\n",
    "#         df_impacto_discente = pd.DataFrame()\n",
    "#         print('Não foi possível encontrar nenhuma ocorrência dos nomes dos discentes com este conjunto de dados')\n",
    "#         pass\n",
    "                \n",
    "#     ## Criar lista com os artigos onde NÃO foi encontado nome de discente\n",
    "#     for i in range(len(df_prod.index)):\n",
    "#         if i not in artigos_com_discentes and i not in lista_semparticipacaodiscente:\n",
    "#             lista_semparticipacaodiscente.append(i)\n",
    "\n",
    "#     ## Apresentar resultados das buscas por nomes de autores docentes e discentes\n",
    "#     lista_titulos = pd.Series(df_prod['TITULO'].values).unique().tolist()\n",
    "#     print(len(lista_titulos),'títulos únicos de artigo encontrados')\n",
    "#     pdoc  = np.round(100*len(artigos_com_docentes)/len(df_prod.index),2)\n",
    "#     spdoc = np.round(100*len(lista_semparticipacaodocente)/len(df_prod.index),2)\n",
    "#     print(f'{len(artigos_com_docentes):4} ({pdoc:6}%) artigos com nome de  docente encontrado, faltando {len(lista_semparticipacaodocente):3} ({spdoc:5}%)')\n",
    "\n",
    "#     pdis = np.round(100*len(artigos_com_discentes)/len(df_prod.index),2)\n",
    "#     spdis = np.round(100*len(lista_semparticipacaodiscente)/len(df_prod.index),2)\n",
    "#     print(f'{len(artigos_com_discentes):4} ({pdis:6}%) artigos com nome de discente encontrado, faltando {len(lista_semparticipacaodiscente):3} ({spdis:5}%)')\n",
    "\n",
    "#     ## A1=100, A2=80, B1=60, B2=40, B3=20, B4=10, B5=2\n",
    "#     soma_impacto=[]\n",
    "#     for linha in df_impacto_docente['EXTRATOS_QUALIS']:\n",
    "#         impacto=0\n",
    "#         for extrato in linha:\n",
    "#             if extrato == 'A1':\n",
    "#                 impacto+=100\n",
    "#             elif extrato == 'A2':\n",
    "#                 impacto+=80\n",
    "#             elif extrato == 'B1':\n",
    "#                 impacto+=60\n",
    "#             elif extrato == 'B2':\n",
    "#                 impacto+=40\n",
    "#             elif extrato == 'B3':\n",
    "#                 impacto+=20\n",
    "#             elif extrato == 'B4':\n",
    "#                 impacto+=10\n",
    "#             elif extrato == 'B5':\n",
    "#                 impacto+=2\n",
    "#             elif extrato == 'C':\n",
    "#                 impacto+=0\n",
    "#             elif extrato == 'nan':\n",
    "#                 impacto+=0\n",
    "#         soma_impacto.append(impacto)\n",
    "\n",
    "#     df_impacto_docente['SOMA_IMPACTO'] = soma_impacto\n",
    "#     qte_anos = (final-inicio+1)\n",
    "#     df_impacto_docente['ANOS'] = qte_anos\n",
    "#     df_impacto_docente['IMPACTO_MEDIO_ANUAL'] = np.round(df_impacto_docente['SOMA_IMPACTO']/df_impacto_docente['ANOS'],1)\n",
    "\n",
    "#     return df_impacto_docente, df_impacto_discente\n",
    "\n",
    "\n",
    "\n",
    "# def apurar_pcd_impacto(df_docentes, df_impacto_docente, df_impacto_discente, meta_pcd=50.0, meta_impacto=150.0):\n",
    "#     print(f'Total de nomes de docentes em análise: {len(df_docentes.index)}')\n",
    "#     print(f'Total de nomes de docentes  encontrados nos artigos: {len(df_impacto_docente.index)}')\n",
    "#     print(f'Total de nomes de discentes encontrados nos artigos: {len(df_impacto_discente.index)}')\n",
    "\n",
    "#     df_docentes_pcd_impacto = df_docentes\n",
    "#     ## Montar lista com os índices do dataframe de artigos onde foram achados nomes de discentes na lista de autores\n",
    "#     lista_participacao_discente = []\n",
    "#     for artigos_discentes in df_impacto_discente['INDICES_ARTIGOS']:\n",
    "#         for indice in artigos_discentes:\n",
    "#             lista_participacao_discente.append(indice)\n",
    "\n",
    "#     ## Contar a quantidade de participações de discentes que ocorrem no dataframe de produção docente\n",
    "#     qte_colab_discente=[]\n",
    "#     for docente,artigos_docente in zip(df_impacto_docente['DOCENTE'], df_impacto_docente['INDICES_ARTIGOS']):\n",
    "#         qte=0\n",
    "#         for indice in artigos_docente:\n",
    "#             if indice in lista_participacao_discente:\n",
    "#                 qte+=1\n",
    "            \n",
    "#         qte_colab_discente.append(qte)\n",
    "\n",
    "#     df_docentes_pcd_impacto['PUBLICAÇÕES']  = df_impacto_docente['AUTORIAS']\n",
    "#     df_docentes_pcd_impacto['COM_DISCENTE'] = qte_colab_discente\n",
    "#     df_docentes_pcd_impacto['PCD'] = np.round(100*(df_docentes_pcd_impacto['COM_DISCENTE']/df_impacto_docente['AUTORIAS']),1)\n",
    "#     df_docentes_pcd_impacto['IMPACTO'] = df_impacto_docente['SOMA_IMPACTO']\n",
    "#     df_docentes_pcd_impacto['IMPACTO_MEDIO_ANUAL'] = df_impacto_docente['IMPACTO_MEDIO_ANUAL']\n",
    "\n",
    "#     ## Definir a meta de produção conjunta com discente e apurar o resultado\n",
    "#     # meta_pcd=50.0\n",
    "#     apuracao_pcd     = df_docentes_pcd_impacto.groupby([df_docentes_pcd_impacto.index,'PCD'])\n",
    "#     df_abaixo_pcd    = apuracao_pcd.filter(lambda x: x['PCD'] < meta_pcd)\n",
    "#     df_atingiram_pcd = apuracao_pcd.filter(lambda x: x['PCD'] >= meta_pcd)\n",
    "\n",
    "#     total_docentes         = len(df_docentes_pcd_impacto.index)\n",
    "\n",
    "#     contagem_abaixometa    = len(df_abaixo_pcd.index)\n",
    "#     contagem_atingindometa = len(df_atingiram_pcd.index)\n",
    "#     indicador_pcd = np.round(100*contagem_atingindometa/total_docentes,1)\n",
    "#     print(f'{indicador_pcd}% dos docentes {contagem_atingindometa}/{total_docentes} atingem a meta de {meta_pcd}% publicação com discente')\n",
    "\n",
    "#     ## Definir a meta de impacto por pesquisador e para o grupo\n",
    "#     # meta_impacto=150\n",
    "#     apuracao_impacto     = df_docentes_pcd_impacto.groupby([df_docentes_pcd_impacto.index,'IMPACTO'])\n",
    "#     df_abaixo_impacto    = apuracao_impacto.filter(lambda x: x['IMPACTO_MEDIO_ANUAL'] < meta_impacto)\n",
    "#     df_atingiram_impacto = apuracao_impacto.filter(lambda x: x['IMPACTO_MEDIO_ANUAL'] >= meta_impacto)\n",
    "\n",
    "#     contagem_abaixometa_impacto    = len(df_abaixo_impacto.index)\n",
    "#     contagem_atingindometa_impacto = len(df_atingiram_impacto.index)\n",
    "#     indicador_impacto = np.round(100*contagem_atingindometa_impacto/total_docentes,1)\n",
    "#     print(f'{indicador_impacto}% dos docentes {contagem_atingindometa_impacto}/{total_docentes} atingem a meta de {meta_impacto} pontos de impacto médio por ano das publicações')\n",
    "\n",
    "#     return df_docentes_pcd_impacto, apuracao_pcd, df_abaixo_pcd, df_atingiram_pcd, indicador_pcd, indicador_impacto"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41cda89d",
   "metadata": {},
   "source": [
    "### Funções para plotagem: \n",
    "    \n",
    "    Plotar gráficos de percentual de participação discente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5b3500c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "from matplotlib.patches import Patch\n",
    "from matplotlib.lines import Line2D\n",
    "from matplotlib.patches import Circle\n",
    "from matplotlib.offsetbox import (TextArea, DrawingArea, OffsetImage, AnnotationBbox)\n",
    "from matplotlib.cbook import get_sample_data\n",
    "plt.rcParams['font.size']      = 12\n",
    "# plt.rcParams[\"figure.figsize\"] = (15,9)\n",
    "\n",
    "\n",
    "\n",
    "def plotar_pcd(df, grupo=False, inicio=False, final=False):\n",
    "    N    = len(df.index)\n",
    "    percentual = (df['PCD'].values.round(1))\n",
    "\n",
    "    ind   = np.arange(N) # the x locations for the groups\n",
    "    width = 0.75         # the width of the bars: can also be len(x) sequence\n",
    "\n",
    "    # criar figura\n",
    "    fig, ax = plt.subplots(figsize=(25,10))\n",
    "\n",
    "    # plotar barras verticais com cores condicionais se abaixo do valor da variável para aceitação\n",
    "    par = 50 \n",
    "    cor = ['yellow' if (x < par) else 'green' for x in percentual]\n",
    "    p1  = ax.bar(ind, percentual, width, \n",
    "                #  yerr=dsvpad, \n",
    "                 error_kw=dict(lw=0.3, capsize=2, capthick=1),\n",
    "                 label='Percentual de publicação com discente', color=cor)\n",
    "\n",
    "    # plotar os rótulos e título\n",
    "    ax.axhline(par, color='red', linewidth=3, linestyle='dotted')\n",
    "    ax.axhline(70, color='gray', linewidth=3, linestyle='dotted')\n",
    "    if (grupo and inicio and final) != False:\n",
    "        ax.set_title(f'Apuração do percentual de publicação de docentes {grupo.upper()} com discente no período de {inicio} a {final}')\n",
    "    elif grupo == False:\n",
    "        ax.set_title(f'Apuração do percentual de publicação de docentes com discente no período de {inicio} a {final}')\n",
    "    else:\n",
    "        ax.set_title(f'Apuração do percentual de publicação com discente')\n",
    "\n",
    "    ax.set_ylabel('Percentual de artigos publicados com discente')\n",
    "    ax.set_xticks(ind)\n",
    "    \n",
    "    labels_pos=np.arange(1,N+1)\n",
    "    ax.set_xticklabels(labels_pos)\n",
    "\n",
    "    # Label with label_type 'center' instead of the default 'edge'\n",
    "    ax.bar_label(p1, label_type='center')\n",
    "    # ax.bar_label(p1, dsvpad)\n",
    "    # ax.set_yticks(range(0,100))\n",
    "    \n",
    "    # respectivo domínio de cada questão no AGREE II\n",
    "    grupos = ['01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01',\n",
    "              '02','02','02','02','02','02','02','02','02','02','02','02','02','02','02','02',]\n",
    "    \n",
    "    # calcular limites de retângulos dos domínios\n",
    "    lista_dominios   = pd.Series(grupos)\n",
    "    largura_dominios = lista_dominios.value_counts().sort_index().values   \n",
    "    altura = 100\n",
    "    rets=[]   \n",
    "    \n",
    "    for i in range(1,len(largura_dominios)+1):\n",
    "        ret = patches.Rectangle((-0.5,0),\n",
    "                                np.sum(largura_dominios[:i]), altura,\n",
    "#                                 linestyle='dashdot',\n",
    "                                linewidth=2,\n",
    "                                edgecolor='b',\n",
    "                                fill = False)\n",
    "        rets.append(ret)\n",
    "    \n",
    "    # plotar os retângulos das dimensões na área do gráfico\n",
    "    for i in rets:\n",
    "        ax.add_patch(i)\n",
    "        \n",
    "    # plotar legenda, comentar para excluir\n",
    "    # ax.legend(bbox_to_anchor=(0.75,-0.05), ncol=2)\n",
    "    \n",
    "    campo='04'\n",
    "    # savefig_respostas(campo)\n",
    "    \n",
    "    plt.show()\n",
    "    return \n",
    "\n",
    "\n",
    "\n",
    "def plotar_medias_impacto(df, grupo=False, inicio=False, final=False):\n",
    "    N      = len(df.index)\n",
    "    pontos = (df['IMPACTO_MEDIO_ANUAL'].values.round(1))\n",
    "\n",
    "    ind   = np.arange(N) # the x locations for the groups\n",
    "    width = 0.75         # the width of the bars: can also be len(x) sequence\n",
    "\n",
    "    # criar figura\n",
    "    fig, ax = plt.subplots(figsize=(25,10))\n",
    "\n",
    "    # plotar barras verticais com cores condicionais se abaixo do valor da variável para aceitação\n",
    "    par = 150 \n",
    "    cor = ['yellow' if (x < par) else 'green' for x in pontos]\n",
    "    p1  = ax.bar(ind, pontos, width, \n",
    "                #  yerr=dsvpad, \n",
    "                 error_kw=dict(lw=0.3, capsize=2, capthick=1),\n",
    "                 label='Pontuação em impacto das publicações de docentes', color=cor)\n",
    "\n",
    "    # plotar os rótulos e título\n",
    "    ax.axhline(par, color='red', linewidth=3, linestyle='dotted')\n",
    "    if (grupo and inicio and final) != False:\n",
    "        ax.set_title(f'Apuração da pontuação de impacto das publicações de docentes {grupo.upper()} no período de {inicio} a {final}')\n",
    "    elif (inicio and final) != False:\n",
    "        ax.set_title(f'Apuração da pontuação de impacto das publicações de docentes no período de {inicio} a {final}')\n",
    "    else:\n",
    "        ax.set_title(f'Apuração da pontuação de impacto médio (total do impacto acumulado / quantidade de anos do período) das publicações de docentes')\n",
    "\n",
    "    ax.set_ylabel('Pontuação ponderada pelo Qualis dos artigos publicados')\n",
    "    ax.set_xticks(ind)\n",
    "    \n",
    "    labels_pos=np.arange(1,N+1)\n",
    "    ax.set_xticklabels(labels_pos)\n",
    "\n",
    "    # Label with label_type 'center' instead of the default 'edge'\n",
    "    ax.bar_label(p1, label_type='center')\n",
    "    # ax.bar_label(p1, dsvpad)\n",
    "    vr_maximo = int(max(pontos)+50)\n",
    "    # ax.set_yticks(range(0,vr_maximo))\n",
    "    \n",
    "    # respectivo domínio de cada questão no AGREE II\n",
    "    grupos = ['01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01','01',\n",
    "              '02','02','02','02','02','02','02','02','02','02','02','02','02','02','02','02',]\n",
    "    \n",
    "    # calcular limites de retângulos dos domínios\n",
    "    lista_dominios   = pd.Series(grupos)\n",
    "    largura_dominios = lista_dominios.value_counts().sort_index().values   \n",
    "    altura = max(pontos)+50\n",
    "    rets=[]   \n",
    "    \n",
    "    for i in range(1,len(largura_dominios)+1):\n",
    "        ret = patches.Rectangle((-0.5,0),\n",
    "                                np.sum(largura_dominios[:i]), altura,\n",
    "#                                 linestyle='dashdot',\n",
    "                                linewidth=2,\n",
    "                                edgecolor='b',\n",
    "                                fill = False)\n",
    "        rets.append(ret)\n",
    "    \n",
    "    # plotar os retângulos das dimensões na área do gráfico\n",
    "    for i in rets:\n",
    "        ax.add_patch(i)\n",
    "        \n",
    "    # plotar legenda, comentar para excluir\n",
    "    # ax.legend(bbox_to_anchor=(0.75,-0.05), ncol=2)\n",
    "    \n",
    "    campo='04'\n",
    "    # savefig_respostas(campo)\n",
    "    \n",
    "    plt.show()\n",
    "    return "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1fa03cb",
   "metadata": {},
   "source": [
    "## Apurar participação discente e impacto artigos dos docentes\n",
    "### Todos os períodos e grupos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a576cd26",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.listdir(pathcsv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ea408ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_nomes_docentes_permanentes   = 'lista_docentes_permanentes.csv'\n",
    "lista_nomes_docentes_colaboradores = 'lista_docentes_colaboradores.csv'\n",
    "df_docentes = montardf_docentes(lista_nomes_docentes_permanentes, lista_nomes_docentes_colaboradores)\n",
    "\n",
    "## Escolha dos arquivos que alimentarão a análise da produção\n",
    "lista_csv = ler_artigostodosperiodos()\n",
    "lista_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a2eb3e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_docentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38c09d4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "pathfilename = os.path.join(pathcsv,'lista_docentes.csv')\n",
    "lista_csv = pd.read_csv(pathfilename,header=None)[0].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6679bfb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_prod   = montardf_producao(lista_csv)\n",
    "\n",
    "## Mostrar quantitativos lidos\n",
    "print(f'\\nCarregado dataframe com {len(df_prod.index)} linhas:')\n",
    "lista_titulos = pd.Series(df_prod['TITULO'].values).unique().tolist()\n",
    "print(f'{len(lista_titulos):4} artigos distintos publicados no período')\n",
    "lista_revistas = pd.Series(df_prod['REVISTA'].values).unique().tolist()\n",
    "print(f'{len(lista_revistas):4} revistas distintas utilizadas no período')\n",
    "\n",
    "## Ler nomes de docentes, discentes e papel de orientador\n",
    "lista_autores_artigos, lista_docentes, lista_orientadores, lista_discentes = montar_listas(lista_csv)\n",
    "qte_docentes=len(lista_docentes)\n",
    "qte_discentes=len(lista_discentes)\n",
    "total_iteracoes=(qte_docentes+qte_discentes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "803e7f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_docentes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "102e2c31",
   "metadata": {},
   "source": [
    "    Organizar lista de autores e iniciais de nomes\n",
    "    PROBLEMA: não está quebrando no número de artigos 1115, mas sim em apenas 2 e última vazia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f515360",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Montar a lista de autores a partir da lista de strings limpa com nomes de autores\n",
    "def organizar_nomes(str_autores_artigo):\n",
    "    erros_organizar  = []\n",
    "    lista_organizada = []\n",
    "    partes_nomes = str_autores_artigo.split(', ')\n",
    "    n       = len(partes_nomes)\n",
    "    pares   = range(0,n+1,2)\n",
    "    impares = range(1,n+1,2)\n",
    "    try:\n",
    "        for i,j in zip(pares,impares):\n",
    "            nome=[]\n",
    "            try:\n",
    "                nomes_ordenado = str(partes_nomes[j].lower()+' '+partes_nomes[i].lower()).replace('  ',' ').strip()\n",
    "            except:\n",
    "                if len(pares) > len(impares):\n",
    "                    nomes_ordenado = str(partes_nomes[j].lower()).replace('  ',' ').strip()\n",
    "                else:\n",
    "                    nomes_ordenado = str(partes_nomes[i].lower()).replace('  ',' ').strip()\n",
    "            lista_organizada.append(nomes_ordenado)\n",
    "    \n",
    "    except Exception as e1:\n",
    "        print('Erro ao montar listas de nomes de autor:',e1)\n",
    "        erros_organizar.append((i,str_autores_artigo))\n",
    "\n",
    "    return lista_organizada, erros_organizar\n",
    "\n",
    "## Quebrar um nome em seu sobrenome seguido das partes de nome\n",
    "def quebrar_partesnomes(nome):\n",
    "    padrao     = padronizar_nome(nome).lower()\n",
    "    sobrenome  = padrao.split(',')[0].strip()\n",
    "    restonomes = padrao.split(',')[1].strip().split(' ')\n",
    "    try:\n",
    "        partenome1 = restonomes[0].strip()\n",
    "    except:\n",
    "        partenome1 = np.NaN\n",
    "    try:\n",
    "        partenome2 = restonomes[1].strip()\n",
    "    except:\n",
    "        partenome2 = np.NaN\n",
    "    try:\n",
    "        partenome3 = restonomes[2].strip()\n",
    "    except:\n",
    "        partenome3 = np.NaN        \n",
    "    # print(f'{sobrenome:15} | {partenome1:1} | {partenome2:1} | {partenome3}')\n",
    "    \n",
    "    return sobrenome, partenome1, partenome2, partenome3\n",
    "\n",
    "\n",
    "## Quebrar um nome em seu sobrenome seguido as iniciais das partes de nome\n",
    "def quebrar_iniciais(nome):\n",
    "    padrao = iniciais_nome(nome).lower()\n",
    "    sobrenome  = padrao.split(',')[0].strip()\n",
    "    restonomes = padrao.split(',')[1].strip().split(' ')\n",
    "\n",
    "    try:\n",
    "        partenome1 = restonomes[0].strip()\n",
    "    except:\n",
    "        partenome1 = np.NaN\n",
    "    try:\n",
    "        partenome2 = restonomes[1].strip()\n",
    "    except:\n",
    "        partenome2 = np.NaN\n",
    "    try:\n",
    "        partenome3 = restonomes[2].strip()\n",
    "    except:\n",
    "        partenome3 = np.NaN        \n",
    "    # print(f'{sobrenome:15} | {partenome1:1} | {partenome2:1} | {partenome3}')\n",
    "    \n",
    "    return sobrenome, partenome1, partenome2, partenome3\n",
    "\n",
    "\n",
    "## compilar padrão regular expression para buscar ocorência de duas das quatro partes de nome dentro de janela de no máximo 2 palavras de distância\n",
    "def compilar_partes(sobrenome, partenome1, partenome2, partenome3):\n",
    "    return re.compile(r'\\b({0}|{1}|{2}|{3})(?:\\W+\\w+){{0,2}}?\\W+({1}&{2}|{2}&{3}|{0}&{1}|{0}&{3})\\b'.format(sobrenome, partenome1, partenome2, partenome3), flags=re.IGNORECASE)\n",
    "\n",
    "def compilar_iniciais(sobrenome, inicial1, inicial2, inicial3):\n",
    "    return re.compile(r'\\b({0})(?:\\W+\\w+){{0,1}}?\\W+({1}|{2}|{3})\\b'.format(sobrenome, inicial1, inicial2, inicial3), flags=re.IGNORECASE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c73ffe9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gerar_dicionarios(df_prod, lista_docentes, lista_discentes, inicio = min(df_prod['Ano']), final  = max(df_prod['Ano'])):\n",
    "    qte_docentes     = len(lista_docentes)\n",
    "    qte_discentes    = len(lista_discentes)\n",
    "    total_iteracoes  = (qte_docentes+qte_discentes)\n",
    "    \n",
    "    ## Monta uma lista de strings com nomes dos autores de cada artigo na forma extraída pelo e-lattes\n",
    "    lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "    qte_artigos         = len(lista_nomes_autores)\n",
    "        \n",
    "    ## Define os limites para considerar duas strings com nomes similares entre si\n",
    "    limite_jaro_nome        = 0.88\n",
    "    limite_jaro_iniciais    = 0.75\n",
    "    limite_jaccard_iniciais = 0.32\n",
    "\n",
    "    ## Função para calcular similaridade dos nomes de docentes com cada nome de autor da lista de autores de cada artigo\n",
    "    t1 = time.time()\n",
    "    dic_nomes_docentes  = {}\n",
    "    dic_nomes_discentes = {}    \n",
    "    erros=[]\n",
    "    rot1='Comparando nome do docente'\n",
    "    rot2='Sobren/Iniciais docen'\n",
    "    rot3='Sobrenome/Iniciais autor'\n",
    "    rot4='I.Doc'\n",
    "    rot5='I.Aut'\n",
    "    rot6='Jaro-Winkler'\n",
    "    rot7='Jaccard'\n",
    "    for m,docente in enumerate(lista_docentes):\n",
    "        achados_docentes     = []\n",
    "        lista_indice_docente = []\n",
    "        lista_qualis_docente = []\n",
    "        docentes_naoencontrados = []          \n",
    "        contagem=m+1\n",
    "        # clear_output(wait=True)       \n",
    "        try:\n",
    "            nome_docente_padronizado = padronizar_nome(docente).lower()\n",
    "            iniciais_nome_docente    = iniciais_nome(docente).lower()\n",
    "            string_iniciais_docente  = ' '.join(x.strip() for x in iniciais_nome_docente.split(',')[1:])\n",
    "            set_iniciais_docente     = converter_lista_set([x.strip() for x in iniciais_nome_docente.split(',')[1:]])                \n",
    "            print(f'\\nCálculo das similaridades autores-docentes (nome/iniciais/Jaccard):')\n",
    "            print(f'{rot1:^40} |{rot2:^20}| {rot3:^25}|{rot4:^5}|{rot5:^5}|{rot6:^15}|{rot7:^10}')\n",
    "            ## Monta a lista de autores com a divisão da string organizada padronizada no formato: {sobrenome, iniciais de nomes}\n",
    "            lst_autores_artigo = []\n",
    "            lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "            for n,nomes_autor in enumerate(lista_nomes_autores):\n",
    "                autores,erros = organizar_nomes(nomes_autor)\n",
    "                for o,autor in enumerate(autores):\n",
    "                    qte_autores_artigo = len(autores)\n",
    "                    # print(f'{o+1:2}/{qte_autores_artigo:2} nomes de autor do artigo em análise, restando {qte_autores_artigo-o-1:2}')\n",
    "                    nome_autor_padronizado = padronizar_nome(autor).lower()\n",
    "                    try:    \n",
    "                        iniciais_nome_autor    = iniciais_nome(autor).lower()\n",
    "                        string_iniciais_autor  = ' '.join(x.strip() for x in iniciais_nome_autor.split(',')[1:])\n",
    "                        set_iniciais_autor     = converter_lista_set([x.strip() for x in iniciais_nome_autor.split(',')[1:]])\n",
    "                        # time.sleep(1)\n",
    "                        ## Cálculos de similaridades entre os nomes do autor e do docente\n",
    "                        if iniciais_nome_docente and iniciais_nome_autor != '':\n",
    "                            similaridade_nome     = get_jaro_distance(iniciais_nome_docente, iniciais_nome_autor)\n",
    "                            similaridade_iniciais = get_jaro_distance(string_iniciais_docente, string_iniciais_autor)\n",
    "                            similaridade_jaccard  = np.round(jaccard_similarity(set_iniciais_docente, set_iniciais_autor),2)\n",
    "                            print(f'\\nCálculo das similaridades autores-discentes (nome/iniciais/Jaccard):')\n",
    "                            print(f'{padronizar_nome(docente):^40} | {iniciais_nome_docente:<20}|{iniciais_nome_autor:<20} {similaridade_nome:^5}|{string_iniciais_docente:^5}|{string_iniciais_autor:^5}|{similaridade_iniciais:^15}|{similaridade_jaccard:^10}')\n",
    "                            clear_output(wait=True)\n",
    "                            if similaridade_nome > limite_jaro_nome and similaridade_iniciais > limite_jaro_iniciais and similaridade_jaccard > limite_jaccard_iniciais:\n",
    "                                if n not in lista_indice_docente:\n",
    "                                    print(f'Similaridade encontrada no artigo {n+1}/{qte_artigos}, docente {m+1}/{qte_docentes}')\n",
    "                                    print(f'{rot1:^40} |{rot2:^20}| {rot3:^25}|{rot4:^5}|{rot5:^5}|{rot6:^15}|{rot7:^10}')\n",
    "                                    print(f'{padronizar_nome(docente):^40} | {iniciais_nome_docente:<20}|{iniciais_nome_autor:<20} {similaridade_nome:^5}|{string_iniciais_docente:^5}|{string_iniciais_autor:^5}|{similaridade_iniciais:^15}|{similaridade_jaccard:^10}')\n",
    "                                    achados_docentes.append(docente)\n",
    "                                    lista_indice_docente.append(n)\n",
    "                                    # print(len(lista_indice_docente))\n",
    "                                    extrato = df_prod['Qualis'][n]\n",
    "                                    lista_qualis_docente.append(extrato)\n",
    "                                    clear_output(wait=True)                                    \n",
    "                    except Exception as e1:\n",
    "                        # print(f'Erro na etapa 1 de gerar_dicionarios, ao tratar iniciais do nome de autor/docente da linha  {n}/{o}/{qte_docentes}/{qte_artigos}')\n",
    "                        # print(e1)\n",
    "                        similaridade_iniciais = np.NaN\n",
    "                        similaridade_jaccard  = np.NaN\n",
    "                        erros.append(('e1_similaridadesdocente',m,n,o,e1))                    \n",
    "                lst_autores_artigo.append(iniciais_nome_autor)\n",
    "            # print(f'Lista organizada de nomes de autores: {len(lst_autores_artigo)} listas de autores de artigos publicados no período')\n",
    "\n",
    "            ## Ao final da leitura todos artigos para cada docente, criar o dicionário de docentes quando docente tenha aparecido na linha de autores\n",
    "            if lista_indice_docente != []:\n",
    "                dic_nomes_docentes[m] = (docente, lista_indice_docente, lista_qualis_docente)\n",
    "            else:\n",
    "                docentes_naoencontrados.append(docente)\n",
    "\n",
    "            tdec=time.time()-t1\n",
    "            # tres=tdec/(m+1)*((qte_docentes-m)+qte_discentes)\n",
    "            # print(f'Analisadas{m+1:4}/{total_iteracoes} iterações em {horas(tdec)}, restando {total_iteracoes-m}. Busca{m+1:4}/{qte_docentes:<4}docente: {docente.title():50}')\n",
    "            # print(f'Nome do docente foi encontrado em {len(lista_indice_docente):2} artigos')\n",
    "        except Exception as e2:\n",
    "            # print(f'Erro na etapa 2 de gerar_dicionarios, ao calcular similaridades de autor/docente  da linha {n}/{o}/{qte_docentes}/{qte_artigos}')\n",
    "            # print(e2)\n",
    "            erros.append(('e2_padronizardocentes',m,n,o,e2)) \n",
    "\n",
    "    ## Função para calcular similaridade dos nomes de discentes com cada nome de autor da lista de autores de cada artigo\n",
    "    for p,discente in enumerate(lista_discentes):\n",
    "        achados_discentes     = []\n",
    "        lista_indice_discente = []\n",
    "        lista_qualis_discente = []\n",
    "        discentes_naoencontrados = []\n",
    "        contagem=m+p+1\n",
    "        # clear_output(wait=True)       \n",
    "        try:\n",
    "            nome_discente_padronizado = padronizar_nome(discente).lower()\n",
    "            iniciais_nome_discente    = iniciais_nome(discente).lower()\n",
    "            string_iniciais_discente  = ' '.join(x.strip() for x in iniciais_nome_discente.split(',')[1:])\n",
    "            set_iniciais_discente     = converter_lista_set([x.strip() for x in iniciais_nome_discente.split(',')[1:]])\n",
    "            rot2='Sobren/Iniciais disce'\n",
    "            rot4='I.Dis'            \n",
    "            ## Monta a lista de autores com a divisão da string organizada padronizada no formato: {sobrenome, iniciais de nomes}\n",
    "            lst_autores_artigo = []\n",
    "            lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "            for n,nomes_autor in enumerate(lista_nomes_autores):\n",
    "                # clear_output(wait=True)\n",
    "                # print(f'Procurando {nome_discente_padronizado.title()} em {n+1:2}/{qte_artigos:<2} artigos, restando {qte_artigos-n-1:<2}')\n",
    "                autores,erros = organizar_nomes(nomes_autor)\n",
    "                for q,autor in enumerate(autores):\n",
    "                    qte_autores_artigo = len(autores)\n",
    "                    nome_autor_padronizado = padronizar_nome(autor).lower()\n",
    "                    # print(f'{q+1:2}/{qte_autores_artigo:2} nomes de autor do artigo em análise, restando {qte_autores_artigo-q-1:2}')\n",
    "                    nome_autor_padronizado = padronizar_nome(autor).lower()\n",
    "                    try:    \n",
    "                        iniciais_nome_autor    = iniciais_nome(autor).lower()\n",
    "                        string_iniciais_autor  = ' '.join(x.strip() for x in iniciais_nome_autor.split(',')[1:])\n",
    "                        set_iniciais_autor     = converter_lista_set([x.strip() for x in iniciais_nome_autor.split(',')[1:]])   \n",
    "                        ## Cálculos de similaridades entre os nomes do autor e do discente\n",
    "                        if iniciais_nome_discente and iniciais_nome_autor != '':\n",
    "                            similaridade_nome     = get_jaro_distance(iniciais_nome_discente, iniciais_nome_autor)\n",
    "                            similaridade_iniciais = get_jaro_distance(string_iniciais_discente, string_iniciais_autor)\n",
    "                            similaridade_jaccard  = np.round(jaccard_similarity(set_iniciais_discente, set_iniciais_autor),2)\n",
    "                            print(f'{padronizar_nome(discente):^40} | {iniciais_nome_discente:<20}|{iniciais_nome_autor:<20} {similaridade_nome:^5}|{string_iniciais_docente:^5}|{string_iniciais_autor:^5}|{similaridade_iniciais:^15}|{similaridade_jaccard:^10}')                            \n",
    "                            if similaridade_nome > limite_jaro_nome and similaridade_iniciais > limite_jaro_iniciais and similaridade_jaccard > limite_jaccard_iniciais:\n",
    "                                if n not in lista_indice_discente:\n",
    "                                    print(f'Similaridade encontrada no artigo {n+1}/{qte_artigos}, discente {p+1}/{qte_discentes}')\n",
    "                                    print(f'{rot1:^40} |{rot2:^20}| {rot3:^25}|{rot4:^5}|{rot5:^5}|{rot6:^15}|{rot7:^10}')\n",
    "                                    print(f'{padronizar_nome(discente):^40} | {iniciais_nome_discente:<20}|{iniciais_nome_autor:<20} {similaridade_nome:^5}|{string_iniciais_discente:^5}|{string_iniciais_autor:^5}|{similaridade_iniciais:^15}|{similaridade_jaccard:^10}')\n",
    "                                    achados_discentes.append(discente)\n",
    "                                    lista_indice_discente.append(n)\n",
    "                                    # print(len(lista_indice_discente))\n",
    "                                    extrato = df_prod['Qualis'][n]\n",
    "                                    lista_qualis_discente.append(extrato)\n",
    "                                    clear_output(wait=True)\n",
    "                    except Exception as e3:\n",
    "                        similaridade_iniciais = np.NaN\n",
    "                        similaridade_jaccard  = np.NaN\n",
    "                        # print(f'Erro na etapa 3 de gerar_dicionarios, ao calcular similaridades de nomes de autor/discente da linha {n}/{o}/{qte_discentes}/{qte_artigos}')\n",
    "                        # print(e3)\n",
    "                        erros.append(('e3_buscadiscentes',p,n,q,e3))\n",
    "        \n",
    "            ## Ao final da leitura todos artigos para cada discente, criar o dicionário de discente quando docente tenha aparecido na linha de autores\n",
    "            if lista_indice_discente != []:\n",
    "                dic_nomes_discentes[o] = (discente, lista_indice_discente, lista_qualis_discente)\n",
    "            else:\n",
    "                discentes_naoencontrados.append(discente)            \n",
    "            \n",
    "            tdec=time.time()-t1\n",
    "            # tres=tdec/(o+p+1)*((qte_discentes-p)+qte_discentes)\n",
    "            # print(f'Analisadas{contagem+1:4}/{total_iteracoes} iterações em {horas(tdec)}, restando {horas(tres)} para iterar {total_iteracoes-contagem-1}. Busca{p+1:4}/{qte_discentes:<4}discente: {discente.title():50}')\n",
    "            # print(f'Nome do discente foi encontrado em {len(lista_indice_discente):2} artigos')   \n",
    "        except Exception as e4:\n",
    "            # print('Erro na etapa 4 de gerar_dicionarios, ao finalizar montagem dos dicionários:',e4)\n",
    "            erros.append(('e4_padronizardiscente',m,n,e4))\n",
    "\n",
    "    return dic_nomes_docentes, dic_nomes_discentes, docentes_naoencontrados, discentes_naoencontrados, erros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "770168bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_nomes_docentes, dic_nomes_discentes, docentes_naoencontrados, discentes_naoencontrados, erros = gerar_dicionarios(df_prod, lista_docentes, lista_discentes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d4b0da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dic_nomes_docentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9f9ef43",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(docentes_naoencontrados),'total de nomes de  docentes não encontrados nos artigos')\n",
    "print(len(discentes_naoencontrados),'total de nomes de discentes não encontrados nos artigos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afedd039",
   "metadata": {},
   "outputs": [],
   "source": [
    "discentes_naoencontrados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9428926a",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(erros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac927dd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "erros[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cdffe87",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lista_artigos_problemas = []\n",
    "# lista_autores_problemas = []\n",
    "# for etapa,docente,i,discente,artigo in erros:\n",
    "#     if i not in lista_artigos_problemas:\n",
    "#         lista_artigos_problemas.append(i)\n",
    "#         lista_autores_problemas.append(df_prod['AUTORES'][i])\n",
    "\n",
    "# df_artigos_problemas=pd.DataFrame(lista_artigos_problemas).reset_index(drop=True)\n",
    "# df_artigos_problemas['LISTA_AUTORES'] = lista_autores_problemas\n",
    "# df_artigos_problemas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8d13905",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ## Lista ordenada alfabeticamente pelos sobrenomes de docentes\n",
    "# lista_docentes_sobrenome=[]\n",
    "# for i in lista_docentes:\n",
    "#     lista_docentes_sobrenome.append(iniciais_nome(i))\n",
    "    \n",
    "# lista_docentes_sobrenome.sort()\n",
    "# for j in lista_docentes_sobrenome:\n",
    "#     print(f'{j.lower()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6a71542",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2017\n",
    "final  = 2022\n",
    "df_impacto_docente, df_impacto_discente = montardf_impacto_docente_discente(df_prod, dic_nomes_docentes, dic_nomes_discentes, inicio, final)\n",
    "df_impacto_docente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7d83d10",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_docentes = montardf_docentes(lista_nomes_docentes_permanentes, lista_nomes_docentes_colaboradores)\n",
    "df_docentes_pcd_impacto, apuracao_pcd, df_abaixo_pcd, df_atingiram_pcd, indicador_pcd, indicador_impacto = apurar_pcd_impacto(df_docentes, df_impacto_docente, df_impacto_discente, meta_pcd=50.0, meta_impacto=150.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b36af03f",
   "metadata": {},
   "outputs": [],
   "source": [
    "plotar_pcd(df_docentes_pcd_impacto)\n",
    "plotar_medias_impacto(df_docentes_pcd_impacto, grupo=False, inicio=False, final=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fafd992d",
   "metadata": {},
   "source": [
    "### Funções avaliação PCD e Impacto Médio Anual: \n",
    "    Avaliar indicadores PCD e Somatório do Fator de Impacto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2bf0beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes):\n",
    "    ## Ler arquivos de dados\n",
    "    lista_csv   = ler_csvptg(inicio, final, tipo, grupo)\n",
    "    df_public   = montardf_producao(lista_csv)\n",
    "    df_docentes = montardf_docentes(lista_nomes_docentes)\n",
    "    lista_autores_artigos, lista_docentes, lista_orientadores, lista_discentes = montar_listas(lista_csv, lista_nomes_docentes)\n",
    "\n",
    "    ## Avaliação da Publicação Conjunta com Discentes (PCD) e do Impacto Médio Anual (IMA)\n",
    "    dic_nomes_docentes, dic_nomes_discentes, docentes_naoencontrados, discentes_naoencontrados, erros = gerar_dicionarios(df_public, lista_docentes, lista_discentes, inicio, final)\n",
    "    df_impacto_docente, df_impacto_discente = montardf_impacto_docente_discente(df_public, dic_nomes_docentes, dic_nomes_discentes, inicio, final)\n",
    "\n",
    "    ## Gerar gráfico de apuração de impacto médio anual por docente\n",
    "    df_docentes_pcd_impacto, apuracao_pcd, df_abaixo_pcd, df_atingiram_pcd, indicador_pcd, indicador_impacto = apurar_pcd_impacto(df_docentes, df_impacto_docente, df_impacto_discente)\n",
    "    plotar_pcd(df_docentes_pcd_impacto, grupo, inicio, final)\n",
    "    plotar_medias_impacto(df_docentes_pcd_impacto, grupo, inicio, final)\n",
    "\n",
    "    return df_public, df_impacto_docente, df_impacto_discente, df_docentes_pcd_impacto, indicador_pcd, indicador_impacto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f85feab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f486c9c2",
   "metadata": {},
   "source": [
    "### Testes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f123b2c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a,b='',''\n",
    "# get_jaro_distance(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adbcfc53",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b='1','0'\n",
    "get_jaro_distance(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c4fb0ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "print(len(lista_nomes_autores))\n",
    "print(lista_nomes_autores[0])\n",
    "\n",
    "## Verifica se a divisão em nomes de autor é par (sobrenome separado de nomes por vírgula)\n",
    "for i in lista_nomes_autores[:14]:\n",
    "    qte_nomes_autor = len(i.split(','))\n",
    "    if qte_nomes_autor/2 != qte_nomes_autor//2:\n",
    "        print(qte_nomes_autor,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f6ed58c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for m,docente in enumerate(lista_docentes):\n",
    "    nome_docente_padronizado = padronizar_nome(docente).lower()\n",
    "    iniciais_nome_docente    = iniciais_nome(docente).lower()\n",
    "    print(iniciais_nome_docente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4278bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "    # ## Monta a lista de autores com a divisão da string de nomes acima por: sobrenome, nomes\n",
    "    # lst_autores_artigo = []\n",
    "    # lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "    # for n,nomes_autor in enumerate(lista_nomes_autores):\n",
    "    #     autores,erros = organizar_nomes(nomes_autor)\n",
    "    #     # print(autores,'\\n')\n",
    "    #     for o,autor in enumerate(autores):\n",
    "    #         # print(autor)\n",
    "    #         # print(f'{o+1:2}/{qte_autores_artigo:2} nomes de autor do artigo em análise, restando {qte_autores_artigo-o-1:2}')\n",
    "    #         sobrenome_iniciais_autor = iniciais_nome(autor).lower()\n",
    "    #         string_iniciais_autor    = ' '.join(x.strip() for x in sobrenome_iniciais_autor.split(',')[1:])\n",
    "    #         set_iniciais_autor       = converter_lista_set([x.strip() for x in sobrenome_iniciais_autor.split(',')[1:]])\n",
    "    #         print(f'{sobrenome_iniciais_autor:20}|{string_iniciais_autor:^9}|{set_iniciais_autor}')\n",
    "    #     lst_autores_artigo.append(sobrenome_iniciais_autor)\n",
    "    # print(f'Lista organizada de nomes de autores: {len(lst_autores_artigo)} listas de autores de artigos publicados no período')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31d9456f",
   "metadata": {},
   "outputs": [],
   "source": [
    "qte_docentes     = len(lista_docentes)\n",
    "qte_discentes    = len(lista_discentes)\n",
    "total_iteracoes  = (qte_docentes+qte_discentes)\n",
    "\n",
    "## Monta uma lista de strings com nomes dos autores de cada artigo\n",
    "lista_nomes_autores = [limpar_nomes(x) for x in df_prod['AUTORES'].values]\n",
    "qte_artigos         = len(lista_nomes_autores)\n",
    "\n",
    "## Monta a lista de autores com a divisão da string de nomes acima por: sobrenome, nomes\n",
    "lst_autores_artigo = []\n",
    "for cada_lista_autores in lista_nomes_autores:\n",
    "    lista_organizada, erros_organizar = organizar_nomes(cada_lista_autores)\n",
    "    lst_autores_artigo.append(lista_organizada)\n",
    "print(f'{len(lst_autores_artigo)} listas de autores de {qte_artigos} artigos publicados no período')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c93f760",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_nomes_autores[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5a8819d",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_autores_artigo[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13e752b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a='a b c de oliveira'\n",
    "padronizar_nome(a)\n",
    "iniciais_nome(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "078c009e",
   "metadata": {},
   "source": [
    "## Apuração segmentada por períodos e grupos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f4ff296",
   "metadata": {},
   "outputs": [],
   "source": [
    "evolucao_pcd=[]\n",
    "evolucao_impacto=[]\n",
    "tipo_analise=[]\n",
    "grupo_analise=[]\n",
    "periodo_analise=[]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0d437b0",
   "metadata": {},
   "source": [
    "## Quadriênio 2017-2020 de Docentes Permanentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7569f83e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_nomes_docentes_permanentes   = 'lista_docentes_permanentes.csv'\n",
    "lista_nomes_docentes_colaboradores = 'lista_docentes_colaboradores.csv'\n",
    "df_docentes = montardf_docentes(lista_nomes_docentes_permanentes, lista_nomes_docentes_colaboradores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "621055ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2017\n",
    "final  = 2020\n",
    "tipo   = 'artigos'\n",
    "grupo  = 'permanentes'\n",
    "lista_nomes_docentes = 'lista_docentes_permanentes.csv'\n",
    "\n",
    "df_public, df_impacto_docente, df_impacto_discente, df_docentespcd, indicador_pcd, indicador_impacto = avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes)\n",
    "evolucao_pcd.append(indicador_pcd)\n",
    "evolucao_impacto.append(indicador_impacto)\n",
    "tipo_analise.append(tipo)\n",
    "grupo_analise.append(grupo)\n",
    "periodo_analise.append([inicio,final])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abc16d3f",
   "metadata": {},
   "source": [
    "## .\n",
    "## Quadriênio 2017-2020 de Docentes Colaboradores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60bb5d66",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2017\n",
    "final  = 2020\n",
    "tipo   = 'artigos'\n",
    "grupo  = 'colaboradores'\n",
    "lista_nomes_docentes = 'lista_docentes_colaboradores.csv'\n",
    "\n",
    "df_public, df_impacto_docente, df_impacto_discente, df_docentespcd, indicador_pcd, indicador_impacto = avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes)\n",
    "evolucao_pcd.append(indicador_pcd)\n",
    "evolucao_impacto.append(indicador_impacto)\n",
    "tipo_analise.append(tipo)\n",
    "grupo_analise.append(grupo)\n",
    "periodo_analise.append([inicio,final])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f33f22aa",
   "metadata": {},
   "source": [
    "## Avaliação de meio termo biênio [2021-2022]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3cd6823",
   "metadata": {},
   "source": [
    "## Biênio 2021-2022 de Docentes Permanentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3d2129f",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2021\n",
    "final  = 2022\n",
    "tipo   = 'artigos'\n",
    "grupo  = 'permanentes'\n",
    "lista_nomes_docentes = 'lista_docentes_permanentes.csv'\n",
    "# lista_nomes_docentes = 'lista_docentes_colaboradores.csv'\n",
    "\n",
    "df_public, df_impacto_docente, df_impacto_discente, df_docentespcd, indicador_pcd, indicador_impacto = avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes)\n",
    "evolucao_pcd.append(indicador_pcd)\n",
    "evolucao_impacto.append(indicador_impacto)\n",
    "tipo_analise.append(tipo)\n",
    "grupo_analise.append(grupo)\n",
    "periodo_analise.append([inicio,final])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f87f19cf",
   "metadata": {},
   "source": [
    "## Biênio 2021-2022 de Docentes Colaboradores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf5b9466",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2021\n",
    "final  = 2022\n",
    "tipo   = 'artigos'\n",
    "grupo  = 'colaboradores'\n",
    "# lista_nomes_docentes = 'lista_docentes_permanentes.csv'\n",
    "lista_nomes_docentes = 'lista_docentes_colaboradores.csv'\n",
    "\n",
    "df_public, df_impacto_docente, df_impacto_discente, df_docentespcd, indicador_pcd, indicador_impacto = avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes)\n",
    "evolucao_pcd.append(indicador_pcd)\n",
    "evolucao_impacto.append(indicador_impacto)\n",
    "tipo_analise.append(tipo)\n",
    "grupo_analise.append(grupo)\n",
    "periodo_analise.append([inicio,final])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8c6a47c",
   "metadata": {},
   "source": [
    "## Evolução de indicadores de gestão do programa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31656a0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_indicadores = pd.DataFrame({\n",
    "    'TIPO': pd.Series(tipo_analise),\n",
    "    'GRUPO': pd.Series(grupo_analise),\n",
    "    'PERIODOS': pd.Series(periodo_analise),\n",
    "    'META_PCD_50%': pd.Series(evolucao_pcd),\n",
    "    'META_IMPACTO_150ANO': pd.Series(evolucao_impacto),\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a687f1f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_indicadores.sort_values(by=['GRUPO'], ascending=True).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be7fd64a",
   "metadata": {},
   "source": [
    "## Conferência em detalhes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a900ec5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio = 2021\n",
    "final  = 2022\n",
    "tipo   = 'artigos'\n",
    "grupo  = 'permanentes'\n",
    "lista_nomes_docentes = 'lista_docentes_permanentes.csv'\n",
    "# lista_nomes_docentes = 'lista_docentes_colaboradores.csv'\n",
    "\n",
    "df_public, df_impacto_docente, df_impacto_discente, df_docentespcd, indicador_pcd, indicador_impacto = avaliar_completo(inicio, final, tipo, grupo, lista_nomes_docentes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f942da4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_impacto_docente[:60]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ccbd6a",
   "metadata": {},
   "source": [
    "## Conferência dos achados de nomes de discentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba57d3db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mostrar_partes_achadas(lista_discentes, lista_autores, verbose=False):\n",
    "    partes_achadas=[]\n",
    "    discentes_achados=[]\n",
    "    erros=[]\n",
    "    if verbose == True:\n",
    "        print(f'{padronizar_titulo(lista_autores).lower()}')\n",
    "    try:\n",
    "        ## Buscar pelas partes de nomes de autor em cada linha de autores de artigo\n",
    "        for nome in lista_discentes:\n",
    "            sobrenome, partenome1, partenome2, partenome3 = quebrar_partesnomes(nome)\n",
    "            if verbose == True:\n",
    "                print(f'{sobrenome}, {partenome1} {partenome2} {partenome3}')\n",
    "            strbusca_partes = compilar_partes(sobrenome, partenome1, partenome2, partenome3)\n",
    "            try:\n",
    "                achados_partes = re.search(strbusca_partes, padronizar_titulo(lista_autores).lower())\n",
    "                if achados_partes.span() !=None:\n",
    "                    partes_achadas.append(achados_partes.groups())\n",
    "                    discentes_achados.append(nome)\n",
    "            except Exception as e:\n",
    "                # print(e)\n",
    "                pass\n",
    "\n",
    "        ## Buscar pelas iniciais de partes de nomes de autor, que seguem um sobrenome em cada linha de autores de artigo\n",
    "        for nome in lista_discentes:\n",
    "            sobrenome, inicial1, inicial2, inicial3 = quebrar_iniciais(nome)\n",
    "            if verbose == True:\n",
    "                print(f'{sobrenome}, {inicial1} {inicial2} {inicial3}')\n",
    "            strbusca_iniciais = compilar_iniciais(sobrenome, inicial1, inicial2, inicial3)\n",
    "            try:\n",
    "                achados_iniciais = re.search(strbusca_iniciais, padronizar_titulo(lista_autores).lower())\n",
    "                if achados_iniciais.span() !=None and achados_iniciais.groups() not in discentes_achados:\n",
    "                    partes_achadas.append(achados_iniciais.groups())\n",
    "                    discentes_achados.append(nome)\n",
    "            except Exception as e:\n",
    "                # print(e)\n",
    "                pass\n",
    "    except Exception as e:\n",
    "        # print(f'Erro ao buscar partes de nome; {e}')\n",
    "        print(e)\n",
    "    \n",
    "    return partes_achadas, discentes_achados\n",
    "\n",
    "def listar_achados(docente):\n",
    "    lista_csv = ler_artigostodosperiodos()\n",
    "    lista_autores_artigos, lista_docentes, lista_orientadores, lista_discentes = montar_listas(lista_csv)\n",
    "\n",
    "    df_filtrado = df_impacto_docente[(df_impacto_docente.DOCENTE==docente)]\n",
    "\n",
    "    lista_indices = df_filtrado['INDICES_ARTIGOS'].values.tolist()[0]\n",
    "    n=100\n",
    "    print('-'*n)\n",
    "    print(f'\\nDocente: {docente} | {len(lista_indices)} Publicações identificadas para no período [{inicio} a {final}]')\n",
    "    print()\n",
    "    for indice in lista_indices:\n",
    "        print('-'*n)\n",
    "        print(f'Índice da publicação: {indice}')\n",
    "        print(df_public.iloc[indice].values[:3])\n",
    "        lista_autores = padronizar_titulo(df_public.iloc[indice].values[4])\n",
    "        partes_achadas, discentes_achados = mostrar_partes_achadas(lista_discentes, lista_autores, verbose=False)\n",
    "        print()\n",
    "        print(lista_autores)\n",
    "        print('\\nPartes de nomes de alunos encontrados na lista de autores:')\n",
    "        print(partes_achadas)\n",
    "        print('\\nNomes de alunos considerados como encontrados na lista de autores:')\n",
    "        print(discentes_achados)\n",
    "\n",
    "def separar_iniciais(nome):\n",
    "    import re\n",
    "    letras_duasconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2}$')            # Duas Letras consoantes maiúsculas juntas do início ao final da string\n",
    "    letras_tresconsnts = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3}$')            # Três Letras consoantes maiúsculas juntas do início ao final da string\n",
    "    letras_duasconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{2},$')       # Duas Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "    letras_tresconsntsvirg = re.compile(r'^[B-DF-HJ-NP-TV-XZ-r]{3},$')       # Três Letras consoantes maiúsculas juntas do início ao final da string, seguidas de vírgula\n",
    "    partes_nome=[]\n",
    "    for j in nome.split(' '):\n",
    "        div_ltrduasconsnts = letras_duasconsnts.findall(j)\n",
    "        div_ltrtriplicadas = letras_tresconsnts.findall(j)\n",
    "        div_ltrduasconsntsvirg = letras_duasconsntsvirg.findall(j)\n",
    "        div_ltrtresconsntsvirg = letras_tresconsntsvirg.findall(j)\n",
    "        if div_ltrduasconsnts or div_ltrtriplicadas:\n",
    "            iniciais_separadas = ' '.join(x for x in j)\n",
    "            partes_nome.append(iniciais_separadas)\n",
    "        elif div_ltrduasconsntsvirg or div_ltrtresconsntsvirg:\n",
    "            iniciais_separadas = ' '.join(x for x in j[:-1])\n",
    "            partes_nome.append(iniciais_separadas+',')\n",
    "        else:\n",
    "            partes_nome.append(j)\n",
    "    nome_separado = ' '.join(x for x in partes_nome).strip()\n",
    "    return nome_separado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1021acef",
   "metadata": {},
   "outputs": [],
   "source": [
    "docente = 'Olindo Assis Martins Filho'\n",
    "listar_achados(docente)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dee2749",
   "metadata": {},
   "source": [
    "## Outras funcionalidades"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "374848af",
   "metadata": {},
   "source": [
    "    Formatar tempo (h:min:seg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72114631",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tempo(start, end):\n",
    "    t=end-start\n",
    "\n",
    "    tempo = timedelta(\n",
    "        weeks   = t//(3600*24*7),\n",
    "        days    = t//(3600*24),\n",
    "        seconds = t,\n",
    "        minutes = t//(60),\n",
    "        hours   = t//(3600),\n",
    "        microseconds=t//1000000,\n",
    "        )\n",
    "    fmt='{H:2}:{M:02}:{S:02}'\n",
    "    return strfdelta(tempo)\n",
    "\n",
    "\n",
    "def horas(segundos): \n",
    "    return time.strftime(\"%H:%M:%S\", time.gmtime(segundos)) \n",
    "\n",
    "\n",
    "def dias_horas_minutos(td):\n",
    "    x = (td.days, td.seconds//3600, (td.seconds//60)%60, td.seconds)\n",
    "    return x #(days, hrs, mins, seconds)\n",
    "\n",
    "\n",
    "def strfdelta(tdelta, fmt='{H:02}h {M:02}m {S:02}s', inputtype='timedelta'):\n",
    "    \"\"\"Convert a datetime.timedelta object or a regular number to a custom-formatted string, \n",
    "    just like the stftime() method does for datetime.datetime objects.\n",
    "\n",
    "    The fmt argument allows custom formatting to be specified.  Fields can \n",
    "    include seconds, minutes, hours, days, and weeks.  Each field is optional.\n",
    "\n",
    "    Some examples:\n",
    "        '{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)\n",
    "        '{W}w {D}d {H}:{M:02}:{S:02}'     --> '4w 5d 8:04:02'\n",
    "        '{D:2}d {H:2}:{M:02}:{S:02}'      --> ' 5d  8:04:02'\n",
    "        '{H}h {S}s'                       --> '72h 800s'\n",
    "\n",
    "    The inputtype argument allows tdelta to be a regular number instead of the  \n",
    "    default, which is a datetime.timedelta object.  Valid inputtype strings: \n",
    "        's', 'seconds', \n",
    "        'm', 'minutes', \n",
    "        'h', 'hours', \n",
    "        'd', 'days', \n",
    "        'w', 'weeks'\n",
    "    \"\"\"\n",
    "\n",
    "    # Convert tdelta to integer seconds.\n",
    "    if inputtype == 'timedelta':\n",
    "        remainder = int(tdelta.total_seconds())\n",
    "    elif inputtype in ['s', 'seconds']:\n",
    "        remainder = int(tdelta)\n",
    "    elif inputtype in ['m', 'minutes']:\n",
    "        remainder = int(tdelta)*60\n",
    "    elif inputtype in ['h', 'hours']:\n",
    "        remainder = int(tdelta)*3600\n",
    "    elif inputtype in ['d', 'days']:\n",
    "        remainder = int(tdelta)*86400\n",
    "    elif inputtype in ['w', 'weeks']:\n",
    "        remainder = int(tdelta)*604800\n",
    "\n",
    "    f = Formatter()\n",
    "    desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]\n",
    "    possible_fields = ('W', 'D', 'H', 'M', 'S')\n",
    "    constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}\n",
    "    values = {}\n",
    "    \n",
    "    for field in possible_fields:\n",
    "        if field in desired_fields and field in constants:\n",
    "            values[field], remainder = divmod(remainder, constants[field])\n",
    "    \n",
    "    return f.format(fmt, **values)\n",
    "\n",
    "\n",
    "# print (timedelta(days=365, hours=8, minutes=15))\n",
    "# print (\"   Hoje é: \" + str(date.today()))\n",
    "# print (\"Agora são: \" + str(datetime.now()))\n",
    "# print (\"Um ano no futuro estaremos em:\" + str(dt.today() + timedelta(days=365)))\n",
    "# hoje = date.today()\n",
    "# print(hoje)\n",
    "# hora = dt.now()\n",
    "# print(hora)\n",
    "# dias_ano = date(hoje.year, 1, 1)\n",
    "# if dias_ano < hoje:\n",
    "#     print (\"Decoridos %d dias do ano\" % ((hoje - dias_ano).days))\n",
    "    \n",
    "# from datetime import datetime\n",
    "# now= datetime.now() #get the current date and time\n",
    "\n",
    "# #%c - local date and time, %x-local's date, %X- local's time\n",
    "# print(now.strftime(\"%c\"))\n",
    "# print(now.strftime(\"%x\"))\n",
    "# print(now.strftime(\"%X\"))\n",
    "\n",
    "# ##### Time Formatting ####\n",
    "# #%I/%H - 12/24 Hour, %M - minute, %S - second, %p - local's AM/PM\n",
    "# print(now.strftime(\"%I:%M:%S %p\")) # 12-Hour:Minute:Second:AM\n",
    "# print(now.strftime(\"%H:%M\")) # 24-Hour:Minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db48cc76",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import logging\n",
    "# from neo4j import GraphDatabase\n",
    "# from neo4j.exceptions import Neo4jError\n",
    "\n",
    "# logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', filename='logs/persister.log')\n",
    "# logger = logging.getLogger(__name__)\n",
    "\n",
    "# class Neo4jPersister:\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._uri = uri\n",
    "#         self._user = user\n",
    "#         self._password = password\n",
    "#         self._driver = GraphDatabase.driver(self._uri, auth=(self._user, self._password))\n",
    "#         self.logger = logger\n",
    "\n",
    "#         # Devem ser persistidos como \n",
    "#         self.tipos = [\n",
    "#             'Identificação',\n",
    "#             'Idiomas',\n",
    "#             'Formação',\n",
    "#             'Atuação Profissional',\n",
    "#             'Linhas de Pesquisa',\n",
    "#             'Áreas',\n",
    "#             'Produções',\n",
    "#             'ProjetosPesquisa',\n",
    "#             'ProjetosExtensão',\n",
    "#             'ProjetosDesenvolvimento',\n",
    "#             'ProjetosOutros',\n",
    "#             'Bancas',\n",
    "#             'Orientações',\n",
    "#             ]\n",
    "\n",
    "#         self.subtipos= [\n",
    "#             'Acadêmica',\n",
    "#             'Pos-Doc',\n",
    "#             'Complementar',\n",
    "#             'Artigos completos publicados em periódicos',\n",
    "#             'Resumos publicados em anais de congressos',\n",
    "#             'Apresentações de Trabalho',\n",
    "#             'Outras produções bibliográficas',\n",
    "#             'Entrevistas, mesas redondas, programas e comentários na mídia',\n",
    "#             'Concurso público',\n",
    "#             'Outras participações',\n",
    "#             'Livros publicados/organizados ou edições',\n",
    "#             'Capítulos de livros publicados',\n",
    "#             'Resumos expandidos publicados em anais de congressos',\n",
    "#             'Resumos publicados em anais de congressos (artigos)',\n",
    "#             'Trabalhos técnicos',\n",
    "#             'Demais trabalhos',\n",
    "#             'Mestrado',\n",
    "#             'Teses de doutorado',\n",
    "#             'Qualificações de Doutorado',\n",
    "#             'Qualificações de Mestrado',\n",
    "#             'Monografias de cursos de aperfeiçoamento/especialização',\n",
    "#             'Trabalhos de conclusão de curso de graduação',\n",
    "#             'Orientações e supervisões concluídas',\n",
    "#             'Citações',\n",
    "#             'Trabalhos completos publicados em anais de congressos',\n",
    "#             'Produtos tecnológicos',\n",
    "#             'Artigos  aceitos para publicação',\n",
    "#             'Assessoria e consultoria',\n",
    "#             'Programas de computador sem registro',\n",
    "#             'Professor titular',\n",
    "#             'Avaliação de cursos',\n",
    "#             'Orientações e supervisões em andamento',\n",
    "#             'Processos ou técnicas',\n",
    "#             'Outras produções artísticas/culturais',\n",
    "#             'Textos em jornais de notícias/revistas',\n",
    "#             'Redes sociais, websites e blogs',\n",
    "#             'Artes Visuais'            \n",
    "#             ]\n",
    "\n",
    "#         self.propriedades = [\n",
    "#             'Nome',\n",
    "#             'ID Lattes',\n",
    "#             'Última atualização',\n",
    "#             ]\n",
    "       \n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "    \n",
    "#     def persistir_revistas_da_planilha(self):\n",
    "#         \"\"\"\n",
    "#         Persiste dados de revistas a partir da planilha 'classificações_publicadas_todas_as_areas_avaliacao1672761192111.xlsx' no Neo4j.\n",
    "\n",
    "#         Args:\n",
    "#             session: Objeto de sessão do Neo4j.\n",
    "#         \"\"\"\n",
    "#         # Leitura da planilha\n",
    "#         dados_qualis = pd.read_excel(os.path.join(LattesScraper.find_repo_root(),'_data','in_xls','classificações_publicadas_todas_as_areas_avaliacao1672761192111.xlsx'))\n",
    "\n",
    "#         # Extração e persistência de dados de revista\n",
    "#         with self._driver.session() as session:\n",
    "#             for index, row in dados_qualis.iterrows():\n",
    "#                 issn = row['ISSN'].replace('-','')\n",
    "#                 nome_revista = row['Título']\n",
    "#                 area_avaliacao = row['Área de Avaliação']\n",
    "#                 estrato = row['Estrato']\n",
    "\n",
    "#                 # Verificação de existência da revista\n",
    "#                 revista_node = session.run(\"\"\"\n",
    "#                     MATCH (j:Revista {issn: $issn})\n",
    "#                     RETURN j\n",
    "#                 \"\"\", issn=issn).single()\n",
    "\n",
    "#                 if not revista_node:\n",
    "#                     # Criação da revista se não existir\n",
    "#                     session.run(\"\"\"\n",
    "#                         CREATE (j:Revista {issn: $issn, nome_revista: $nome_revista, area_avaliacao: $area_avaliacao, estrato: $estrato})\n",
    "#                     \"\"\", nome_revista=nome_revista, issn=issn, area_avaliacao=area_avaliacao,  estrato=estrato)\n",
    "\n",
    "#     # Testes Ok! \n",
    "#     def persist_pessoa_nodes(self, dict_list):\n",
    "#         query_pessoa = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         ON CREATE SET p.nome = $nome, p.ultima_atualizacao = $ultima_atualizacao\n",
    "#         ON MATCH SET p.nome = $nome, p.ultima_atualizacao = $ultima_atualizacao\n",
    "#         \"\"\"\n",
    "#         try:\n",
    "#             with self._driver.session() as session:\n",
    "#                 for item in dict_list:\n",
    "#                     identificacao = item.get('Identificação')\n",
    "#                     nome = identificacao.get('Nome')\n",
    "#                     id_lattes = identificacao.get('ID Lattes')\n",
    "#                     ultima_atualizacao = identificacao.get('Última atualização')\n",
    "#                     if nome:\n",
    "#                         session.run(query_pessoa, id_lattes=id_lattes, nome=nome, ultima_atualizacao=ultima_atualizacao)\n",
    "#         except Exception as e:\n",
    "#             self.logger.error('Erro ao criar node \"Pesquisador\": {}'.format(e))\n",
    "\n",
    "#     # Testes Ok!         \n",
    "#     def persist_pesquisador_grande_area_relationships(self, dict_list):\n",
    "#         query_rel_pessoa_grande_area = \"\"\"\n",
    "#         MATCH (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MATCH (ga:GrandeArea {nome: $grande_area_nome})\n",
    "#         MERGE (p)-[:ATUA_EM]->(ga)\n",
    "#         \"\"\"\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             for item in dict_list:\n",
    "#                 identificacao = item.get('Identificação')\n",
    "#                 id_lattes = identificacao.get('ID Lattes')\n",
    "#                 areas = item.get('Áreas').values()\n",
    "#                 for area_string in areas:\n",
    "#                     grande_area_nome, _, _ = self.extract_area_info(area_string)\n",
    "#                     if grande_area_nome:\n",
    "#                         session.run(query_rel_pessoa_grande_area, id_lattes=id_lattes, grande_area_nome=grande_area_nome)\n",
    "\n",
    "#     # Testes Ok! \n",
    "#     def persist_areas_nodes(self, dict_list):\n",
    "#         query_grande_area = \"\"\"\n",
    "#         MERGE (ga:GrandeArea {nome: $nome})\n",
    "#         \"\"\"\n",
    "#         query_area = \"\"\"\n",
    "#         MATCH (ga:GrandeArea {nome: $grande_area_nome})\n",
    "#         MERGE (a:Area {nome: $nome}) ON CREATE SET a:Area\n",
    "#         MERGE (ga)-[:CONTEM]->(a)\n",
    "#         \"\"\"\n",
    "#         query_subarea = \"\"\"\n",
    "#         MATCH (a:Area {nome: $area_nome})\n",
    "#         MERGE (sa:Subarea {nome: $nome}) ON CREATE SET sa:Subarea\n",
    "#         MERGE (a)-[:CONTEM]->(sa)\n",
    "#         \"\"\"\n",
    "#         query_rel_pessoa_grande_area = \"\"\"\n",
    "#         MATCH (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MATCH (ga:GrandeArea {nome: $grande_area_nome})\n",
    "#         MERGE (p)-[:ATUA_EM]->(ga)    \n",
    "#         \"\"\"\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             for item in dict_list:\n",
    "#                 areas = item.get('Áreas').values()\n",
    "#                 for area_string in areas:\n",
    "#                     grande_area_nome, area_nome, subarea_nome = self.extract_area_info(area_string)\n",
    "                    \n",
    "#                     # Verificar se o nome não está vazio\n",
    "#                     if grande_area_nome:\n",
    "#                         session.run(query_grande_area, nome=grande_area_nome)\n",
    "#                     if area_nome:\n",
    "#                         session.run(query_area, grande_area_nome=grande_area_nome, nome=area_nome)\n",
    "#                     if subarea_nome:\n",
    "#                         session.run(query_subarea, area_nome=area_nome, nome=subarea_nome)\n",
    "                    \n",
    "#                     # Adicionar relacionamento Pesquisador - GrandeÁrea\n",
    "#                     id_lattes = item['Identificação']['ID Lattes']\n",
    "#                     if grande_area_nome:\n",
    "#                         session.run(query_rel_pessoa_grande_area, id_lattes=id_lattes, grande_area_nome=grande_area_nome)\n",
    "\n",
    "#     # Testes Ok! \n",
    "#     @staticmethod\n",
    "#     def extract_area_info(area_string):\n",
    "#         # Extraindo os nomes de GrandeÁrea, Área e Subárea da string\n",
    "#         try:\n",
    "#             grande_area_nome = area_string.split('/')[0].strip().split(': ')[1]\n",
    "#         except:\n",
    "#             grande_area_nome = ''\n",
    "#         try:\n",
    "#             area_nome = area_string.split('/')[1].strip().split(': ')[1]\n",
    "#         except:\n",
    "#             area_nome = ''\n",
    "#         try:\n",
    "#             subarea_nome = area_string.split('/')[2].strip().split(': ')[1]\n",
    "#         except:\n",
    "#             subarea_nome = ''\n",
    "#         return grande_area_nome, area_nome, subarea_nome\n",
    "\n",
    "#     ## PRODUÇÕES\n",
    "#     def persist_producoes_pesquisador(self, dict_list):\n",
    "#         with self._driver.session() as session:\n",
    "#             for pesq in dict_list:\n",
    "#                 identificacao = pesq.get('Identificação')\n",
    "#                 id_lattes = identificacao.get('ID Lattes')\n",
    "#                 producoes = pesq.get('Produções')\n",
    "\n",
    "#                 if not isinstance(producoes, dict):\n",
    "#                     print(f\"Erro!! Dicionário da seção 'Produções' não encontrado para {id_lattes}\")\n",
    "#                     continue\n",
    "\n",
    "#                 for chave_producao, valores_producao in producoes.items():\n",
    "#                     print(f'{chave_producao} | {valores_producao}')\n",
    "#                     if chave_producao == 'Artigos completos publicados em periódicos':\n",
    "#                         # self.persistir_artigos_completos(session, id_lattes, valores_producao)\n",
    "#                         self.persistir_artigos_revistas(session, id_lattes, valores_producao)\n",
    "\n",
    "#     def _get_or_create_node(self, session, label, properties):\n",
    "#         properties = [x.rstrip('.') for x in properties]\n",
    "#         node = session.run(\"MATCH (n: {label}) WHERE {properties} RETURN n\", {\"label\": label, \"properties\": properties}).single()\n",
    "\n",
    "#         if not node:\n",
    "#             node = session.run(\"CREATE (n: {label} {properties}) RETURN n\", {\"label\": label, \"properties\": properties}).single()[\"n\"]\n",
    "#             self._node_created_count += 1\n",
    "\n",
    "#         return node\n",
    "\n",
    "#     def persist_tipo_producao(self, session, id_lattes, tipo_producao):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (t:TipoProducao {nome: $tipo_producao})\n",
    "#         MERGE (p)-[:PRODUZ]->(t)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, tipo_producao=tipo_producao)\n",
    "#         summary = result.consume()\n",
    "#         return summary.counters.nodes_created, summary.counters.nodes_deleted, summary.counters.relationships_created, summary.counters.relationships_deleted\n",
    "\n",
    "#     def persist_subtipo_producao(self, session, id_lattes, tipo_producao, subtipo_producao, dados_producao):\n",
    "#         def checar_e_serializar(dados):\n",
    "#             \"\"\" Verifica e serializa dicionários recursivamente \"\"\"\n",
    "#             if isinstance(dados, dict):\n",
    "#                 for chave, valor in dados.items():\n",
    "#                     if isinstance(valor, dict):\n",
    "#                         dados[chave] = json.dumps(valor)\n",
    "#                     # Checagem adicional para outros tipos inválidos, se necessário\n",
    "#             return dados\n",
    "#         # Serialização recursiva do dicionário\n",
    "#         dados_producao = checar_e_serializar(dados_producao)\n",
    "\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (t:TipoProducao {nome: $tipo_producao})\n",
    "#         MERGE (s:SubtipoProducao {nome: $subtipo_producao})\n",
    "#         MERGE (p)-[PRODUZ:]->(t)-[:DO_TIPO]->(s)\n",
    "#         \"\"\"\n",
    "\n",
    "#         if subtipo_producao in [\"ArtigoCompleto\", \"ResumoCongresso\", \"ApresentacaoTrabalho\", \"OutrasProducoesBibliograficas\"]:\n",
    "#             query_create_node += \"\"\"\n",
    "#             MERGE (o:Ocorrencia {tipo: $subtipo_producao, dados: $dados})\n",
    "#             MERGE (s)-[:OCORRENCIA]->(o)\n",
    "#             \"\"\"\n",
    "\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, tipo_producao=tipo_producao, \n",
    "#                             subtipo_producao=subtipo_producao, dados=dados_producao)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "\n",
    "#         return summary.counters.nodes_created, summary.counters.nodes_deleted, summary.counters.relationships_created, summary.counters.relationships_deleted\n",
    "\n",
    "#     def persistir_artigos_completos(self, session, id_lattes, dados):\n",
    "#         created_nodes = 0\n",
    "#         updated_nodes = 0\n",
    "#         created_relations = 0\n",
    "#         updated_relations = 0\n",
    "        \n",
    "#         for dados_artigo in dados:\n",
    "#             dados_artigo['dados'] = json.dumps(dados_artigo)  # Conversão para JSON da estrutura completa\n",
    "#             query_create_node_artigo = \"\"\"\n",
    "#                 MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#                 CREATE (a:ArtigoPublicado {\n",
    "#                     ano: $ano,\n",
    "#                     fator_impacto_jcr: $fator_impacto_jcr,\n",
    "#                     ISSN: $ISSN,\n",
    "#                     titulo: $titulo,\n",
    "#                     revista: $revista,\n",
    "#                     autores: $autores,\n",
    "#                     Qualis: $Qualis,\n",
    "#                     DOI: $DOI,\n",
    "#                     dados: $dados_artigo\n",
    "#                 })\n",
    "#                 CREATE (p)-[:PRODUZ]->(a)\n",
    "\n",
    "#                 MERGE (j:Revista {nome: $revista, issn: $ISSN})\n",
    "#                 CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "#             \"\"\"\n",
    "\n",
    "#             result_artigo = session.run(query_create_node_artigo, \n",
    "#                                 id_lattes=id_lattes, \n",
    "#                                 ano=dados_artigo['ano'],\n",
    "#                                 fator_impacto_jcr=dados_artigo['fator_impacto_jcr'],\n",
    "#                                 ISSN=dados_artigo['ISSN'],\n",
    "#                                 titulo=dados_artigo['titulo'],\n",
    "#                                 revista=dados_artigo['revista'],\n",
    "#                                 autores=dados_artigo['autores'],\n",
    "#                                 Qualis=dados_artigo['Qualis'],\n",
    "#                                 DOI=dados_artigo['DOI'],\n",
    "#                                 dados_artigo=dados_artigo\n",
    "#                                 )\n",
    "#             summary_artigo = result_artigo.consume()\n",
    "#             created_nodes += summary_artigo.counters.nodes_created\n",
    "#             updated_nodes += summary_artigo.counters.nodes_deleted\n",
    "#             created_relations += summary_artigo.counters.relationships_created\n",
    "#             updated_relations += summary_artigo.counters.relationships_deleted\n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "\n",
    "#     def persistir_artigos_completos(self, session, id_lattes, dados):\n",
    "#         created_nodes = 0\n",
    "#         updated_nodes = 0\n",
    "#         created_relations = 0\n",
    "#         updated_relations = 0\n",
    "                \n",
    "#         for dados_artigo in dados:\n",
    "#             ano = dados_artigo['ano']\n",
    "#             impact_jcr = dados_artigo['fator_impacto_jcr']\n",
    "#             issn = dados_artigo['ISSN']\n",
    "#             titulo = dados_artigo['titulo']\n",
    "#             revista = dados_artigo['revista']\n",
    "#             autores = dados_artigo['autores']\n",
    "#             qualis = dados_artigo['Qualis']\n",
    "#             doi = dados_artigo['DOI']\n",
    "\n",
    "#             query_create_node_artigo = \"\"\"\n",
    "#                 MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#                 CREATE (a:ArtigoPublicado {ano: $ano, impact_jcr: $impact_jcr, issn: $issn, titulo: $titulo, revista: $revista, autores: $autores, qualis: $qualis, doi: $doi})\n",
    "#                 CREATE (p)-[:PRODUZ]->(a)\n",
    "#                 MERGE (j:Revista {nome: $revista, issn: $issn})\n",
    "#                 CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "#             \"\"\"\n",
    "#             print(query_create_node_artigo)\n",
    "#             result_artigo = session.run(query_create_node_artigo, \n",
    "#                                 id_lattes=id_lattes, \n",
    "#                                 ano=ano,\n",
    "#                                 impact_jcr=impact_jcr,\n",
    "#                                 issn=issn,\n",
    "#                                 titulo=titulo,\n",
    "#                                 revista=revista,\n",
    "#                                 autores=autores,\n",
    "#                                 qualis=qualis,\n",
    "#                                 doi=doi,\n",
    "#                                 )\n",
    "#             summary_artigo = result_artigo.consume()\n",
    "#             created_nodes += summary_artigo.counters.nodes_created\n",
    "#             updated_nodes += summary_artigo.counters.nodes_deleted\n",
    "#             created_relations += summary_artigo.counters.relationships_created\n",
    "#             updated_relations += summary_artigo.counters.relationships_deleted\n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def buscar_revista_por_issn(self, session, issn):\n",
    "#         query = \"\"\"\n",
    "#             MATCH (revista:Revista {issn: $issn})\n",
    "#             RETURN revista\n",
    "#         \"\"\"\n",
    "\n",
    "#         try:\n",
    "#             result = session.run(query, issn=issn)\n",
    "#             return result.single()\n",
    "#         except Neo4jError as e:\n",
    "#             print(f\"Erro Neo4j ao buscar a revista por ISSN: {e}\")\n",
    "#             return None\n",
    "        \n",
    "#     def persistir_artigos_revistas(self, session, id_lattes, dados):\n",
    "#         \"\"\"\n",
    "#         Função para persistir os dados de artigos completos publicados em periódicos.\n",
    "\n",
    "#         Args:\n",
    "#             session (neo4j.Session): Sessão Neo4j.\n",
    "#             id_lattes (str): ID do Lattes do pesquisador.\n",
    "#             dados (dict): Dicionário contendo os dados dos artigos.\n",
    "\n",
    "#         Returns:\n",
    "#             None\n",
    "#         \"\"\"\n",
    "\n",
    "#         for artigo in dados:\n",
    "#             # Extraindo informações do artigo\n",
    "#             revista_nome  = ''\n",
    "#             created_nodes = ''\n",
    "#             ano = artigo['ano']\n",
    "#             impact_jcr = artigo['fator_impacto_jcr']\n",
    "#             issn = artigo['ISSN']\n",
    "#             titulo = artigo['titulo']\n",
    "#             revista = artigo['revista']\n",
    "#             autores = artigo['autores']\n",
    "#             data_issn = artigo['data_issn']\n",
    "#             doi = artigo['DOI']\n",
    "#             qualis = artigo['Qualis']\n",
    "\n",
    "#             query_create_node_artigo = \"\"\"\n",
    "#                 MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#                 CREATE (a:ArtigoPublicado {ano: $ano, impact_jcr: $impact_jcr, issn: $issn, titulo: $titulo, revista: $revista, autores: $autores, qualis: $qualis, doi: $doi})\n",
    "#                 CREATE (p)-[:PRODUZ]->(a)\n",
    "#                 MERGE (j:Revista {nome: $revista, issn: $issn})\n",
    "#                 CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "#             \"\"\"\n",
    "            \n",
    "#             # Buscando o nó da revista\n",
    "#             revista_node = self.buscar_revista_por_issn(session, issn)\n",
    "\n",
    "#             # Criando o nó do artigo\n",
    "#             with session.begin_transaction() as tx:\n",
    "#                 tx.run(query_create_node_artigo,\n",
    "#                     id_lattes=id_lattes,\n",
    "#                     ano=ano,\n",
    "#                     impact_jcr=impact_jcr,\n",
    "#                     issn=issn,\n",
    "#                     titulo=titulo,\n",
    "#                     revista=revista,\n",
    "#                     autores=autores,\n",
    "#                     data_issn=data_issn,\n",
    "#                     doi=doi,\n",
    "#                     qualis=qualis\n",
    "#                     )\n",
    "\n",
    "#                 # Criando o relacionamento PUBLICADO_EM\n",
    "#                 if revista_node is not None:\n",
    "#                     node_revista = revista_node[0][1]\n",
    "#                     if node_revista is not None:\n",
    "#                         revista_nome = node_revista['nome_revista']\n",
    "#                         revista_issn = node_revista['issn']\n",
    "#                         revista_area_avaliacao = node_revista['area_avaliacao']\n",
    "#                         revista_estrato = node_revista['estrato']\n",
    "\n",
    "#                     if revista_nome:\n",
    "#                         tx.run(\"\"\"\n",
    "#                             MATCH (a:ArtigoPublicado {doi: $doi}), (j:Revista {nome_revista: $revista_nome, issn: $revista_issn, area_avaliacao: $revista_area_avaliacao, estrato: $revista_estrato})\n",
    "#                             CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "#                         \"\"\", doi=doi, revista_nome=revista_nome, revista_issn=revista_issn, revista_area_avaliacao=revista_area_avaliacao, revista_estrato=revista_estrato)\n",
    "\n",
    "#                     else:\n",
    "#                         print(\"Erro: O nó da revista não foi encontrado para o ISSN\", issn)\n",
    "#                         # Lógica de tratamento de erro (opcional)\n",
    "#                 else:\n",
    "#                     print(\"Erro: O retorno para a revista com ISSN\", issn, \"é None.\")\n",
    "\n",
    "#                 tx.commit()\n",
    "\n",
    "#         # Atualização dos contadores\n",
    "#         with session.begin_transaction() as tx:\n",
    "#             created_nodes += tx.run(\"MATCH (n) WHERE n:ArtigoPublicado RETURN count(n)\").single()[0]\n",
    "#             updated_nodes += tx.run(\"MATCH (n) WHERE n:ArtigoPublicado SET n.updated_at = datetime() RETURN count(n)\").single()[0]\n",
    "#             created_relations += tx.run(\"MATCH (r) WHERE r:PUBLICADO_EM RETURN count(r)\").single()[0]\n",
    "\n",
    "#     def persistir_resumos_congressos(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (r:ResumoCongresso {titulo: $titulo, ano: $ano, evento: $evento, autores: $autores, data_issn: $data_issn, doi: $doi})\n",
    "#         MERGE (p)-[:PRODUZ]->(r)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_apresentacoes_trabalho(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (a:ApresentacaoTrabalho {\n",
    "#             titulo: $titulo,\n",
    "#             ano: $ano,\n",
    "#             evento: $evento,\n",
    "#             autores: $autores\n",
    "#         })\n",
    "#         MERGE (p)-[:PRODUZ]->(a)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_outras_producoes_bibliograficas(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (o:OutrasProducoesBibliograficas {\n",
    "#             titulo: $titulo,\n",
    "#             ano: $ano,\n",
    "#             autores: $autores,\n",
    "#             doi: $doi\n",
    "#         })\n",
    "#         MERGE (p)-[:PRODUZ]->(o)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_orientacoes_concluidas(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (o:OrientacaoConcluida {\n",
    "#             tipo: $tipo,\n",
    "#             titulo: $titulo,\n",
    "#             ano: $ano,\n",
    "#             autor: $autor,\n",
    "#             instituicao: $instituicao\n",
    "#         })\n",
    "#         MERGE (p)-[:ORIENTA]->(o)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_participacoes_bancas(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (b:Banca {\n",
    "#             tipo: $tipo,\n",
    "#             titulo: $titulo,\n",
    "#             ano: $ano,\n",
    "#             instituicao: $instituicao\n",
    "#         })\n",
    "#         MERGE (p)-[:PARTICIPA_BANCA]->(b)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_projetos_pesquisa(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (pr:ProjetoPesquisa {\n",
    "#             titulo: $titulo,\n",
    "#             ano_inicio: $ano_inicio,\n",
    "#             ano_fim: $ano_fim,\n",
    "#             agencia_financiadora: $agencia_financiadora,\n",
    "#             valor_financiamento: $valor_financiamento\n",
    "#         })\n",
    "#         MERGE (p)-[:COORDENA]->(pr)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, dados=dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "#     def persistir_premios_distincoes(self, session, id_lattes, dados):\n",
    "#         query_create_node = \"\"\"\n",
    "#         MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "#         MERGE (pd:PremioDistincao {\n",
    "#             titulo: $titulo,\n",
    "#             ano: $ano,\n",
    "#             instituicao: $instituicao,\n",
    "#         })\n",
    "#         MERGE (p)-[:RECEBE]->(pd)\n",
    "#         \"\"\"\n",
    "#         result = session.run(query_create_node, id_lattes=id_lattes, **dados)\n",
    "\n",
    "#         # Obtendo as informações de contadores\n",
    "#         summary = result.consume()\n",
    "#         created_nodes = summary.counters.nodes_created\n",
    "#         updated_nodes = summary.counters.nodes_deleted  \n",
    "#         created_relations = summary.counters.relationships_created\n",
    "#         updated_relations = summary.counters.relationships_deleted \n",
    "\n",
    "#         return created_nodes, updated_nodes, created_relations, updated_relations\n",
    "\n",
    "# uri = \"bolt://localhost:7687\"\n",
    "# user = \"neo4j\"\n",
    "# password = \"password\"\n",
    "# persister = Neo4jPersister(uri, user, password)\n",
    "\n",
    "\n",
    "    # def run(self, query, **parameters):\n",
    "    #     with self.driver.session() as session:\n",
    "    #         return session.run(query, **parameters)\n",
    "\n",
    "    ## Agrupando nós de artigos por revista\n",
    "    # def persistir_artigos_revistas(self, session, id_lattes, dados):\n",
    "    #     created_nodes = 0\n",
    "    #     updated_nodes = 0\n",
    "    #     created_relations = 0\n",
    "    #     updated_relations = 0\n",
    "\n",
    "    #     for dados_artigo in dados:\n",
    "    #         ano = dados_artigo['ano']\n",
    "    #         impact_jcr = dados_artigo['fator_impacto_jcr']\n",
    "    #         issn = dados_artigo['ISSN']\n",
    "    #         titulo = dados_artigo['titulo']\n",
    "    #         revista = dados_artigo['revista']\n",
    "    #         autores = dados_artigo['autores']\n",
    "    #         qualis = dados_artigo['Qualis']\n",
    "    #         doi = dados_artigo['DOI']\n",
    "            \n",
    "    #         query_create_node_artigo = \"\"\"\n",
    "    #             MERGE (p:Pesquisador {id_lattes: $id_lattes})\n",
    "    #             CREATE (a:ArtigoPublicado {ano: $ano, impact_jcr: $impact_jcr, issn: $issn, titulo: $titulo, revista: $revista, autores: $autores, qualis: $qualis, doi: $doi})\n",
    "    #             CREATE (p)-[:PRODUZ]->(a)\n",
    "    #             MERGE (j:Revista {nome: $revista, issn: $issn})\n",
    "    #             CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "    #         \"\"\"\n",
    "\n",
    "    #         with session.begin_transaction() as tx:\n",
    "    #             print(\"DEBUG: ISSN da revista:\", issn)\n",
    "    #             # Verificação de existência da revista\n",
    "    #             revista_node = tx.run(\"\"\"\n",
    "    #                 MATCH (j:Revista {issn: $issn})\n",
    "    #                 RETURN j\n",
    "    #             \"\"\", issn=issn).single()\n",
    "\n",
    "    #             if not revista_node:\n",
    "    #                 # Revista não encontrada, crie-a\n",
    "    #                 tx.run(\"\"\"\n",
    "    #                     CREATE (j:Revista {nome: $revista, issn: $issn})\n",
    "    #                 \"\"\", revista=revista, issn=issn)\n",
    "\n",
    "    #                 revista_node = tx.run(\"\"\"\n",
    "    #                     MATCH (j:Revista {issn: $issn})\n",
    "    #                     RETURN j\n",
    "    #                 \"\"\", issn=issn).single()\n",
    "\n",
    "    #             if revista_node is not None:\n",
    "    #                 print(\"DEBUG: Propriedades do nó Revista:\", revista_node.items())  \n",
    "    #                 node_revista = revista_node[0]  # Extrair o objeto Node\n",
    "    #                 print(f\"revista_node[0] {node_revista}\")\n",
    "    #                 issn = node_revista['issn']  # Acessar a propriedade 'issn'\n",
    "    #                 print(f\"node_revista['issn'] {issn}\")\n",
    "    #                 revista_nome = node_revista['nome_revista']\n",
    "    #                 revista_area_avaliacao = node_revista['area_avaliacao']\n",
    "    #                 revista_estrato = node_revista['estrato']\n",
    "    #             else:\n",
    "    #                 print(\"Erro: O retorno para a revista com ISSN\", issn, \"é None.\")\n",
    "\n",
    "    #             # Criação do nó do artigo\n",
    "    #             tx.run(query_create_node_artigo, \n",
    "    #                 id_lattes=id_lattes, \n",
    "    #                 ano=ano,\n",
    "    #                 impact_jcr=impact_jcr,\n",
    "    #                 issn=issn,\n",
    "    #                 titulo=titulo,\n",
    "    #                 revista=revista,\n",
    "    #                 autores=autores,\n",
    "    #                 qualis=qualis,\n",
    "    #                 doi=doi)\n",
    "\n",
    "    #             # Criação do relacionamento PUBLICADO_EM\n",
    "    #             tx.run(\"\"\"\n",
    "    #                 MATCH (a:ArtigoPublicado {doi: $doi}), (j:Revista {nome_revista: $revista_nome, issn: $issn, area_avaliacao: $revista_area_avaliacao, estrato: $revista_estrato})\n",
    "    #                 CREATE (a)-[:PUBLICADO_EM]->(j)\n",
    "    #             \"\"\", doi=doi, revista_nome=revista_nome, issn=issn, revista_area_avaliacao=revista_area_avaliacao, revista_estrato=revista_estrato)\n",
    "\n",
    "    #             tx.commit()\n",
    "\n",
    "    #         # Atualização dos contadores\n",
    "    #         created_nodes += tx.run(\"MATCH (n) WHERE n:ArtigoPublicado RETURN count(n)\").single()[0]\n",
    "    #         updated_nodes += tx.run(\"MATCH (n) WHERE n:ArtigoPublicado SET n.updated_at = datetime() RETURN count(n)\").single()[0]\n",
    "    #         created_relations += tx.run(\"MATCH (r) WHERE r:PUBLICADO_EM RETURN count(r)\").single()[0]\n",
    "    #         updated_relations += tx.run(\"MATCH (r) WHERE r:PUBLICADO_EM SET r.updated_at = datetime() RETURN count(r)\").single()[0]\n",
    "\n",
    "    #     return created_nodes, updated_nodes, created_relations, updated_relations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23d90ac2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import json\n",
    "# import logging\n",
    "\n",
    "# from neo4j import GraphDatabase\n",
    "\n",
    "# class Neo4jDataPersister:\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._uri = uri\n",
    "#         self._user = user\n",
    "#         self._password = password\n",
    "#         self._driver = GraphDatabase.driver(self._uri, auth=(self._user, self._password))\n",
    "#         self.logger = logging.getLogger(__name__)\n",
    "\n",
    "#         self._node_created_count = 0\n",
    "#         self._node_updated_count = 0\n",
    "#         self._node_deleted_count = 0\n",
    "\n",
    "#         self._relationship_created_count = 0\n",
    "#         self._relationship_updated_count = 0\n",
    "#         self._relationship_deleted_count = 0\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def persist_data_from_json(self, json_data):\n",
    "#         with self._driver.session() as session:\n",
    "#             self._persist_data(session, json_data)\n",
    "\n",
    "#         self.logger.info(\"Total nodes created: %d\", self._node_created_count)\n",
    "#         self.logger.info(\"Total nodes updated: %d\", self._node_updated_count)\n",
    "#         self.logger.info(\"Total nodes deleted: %d\", self._node_deleted_count)\n",
    "\n",
    "#         self.logger.info(\"Total relationships created: %d\", self._relationship_created_count)\n",
    "#         self.logger.info(\"Total relationships updated: %d\", self._relationship_updated_count)\n",
    "#         self.logger.info(\"Total relationships deleted: %d\", self._relationship_deleted_count)\n",
    "\n",
    "#     def _persist_data(self, session, data):\n",
    "#         if isinstance(data, dict):  # Check if it's a dictionary\n",
    "#             for key, value in data.items():\n",
    "#                 if key == 'Identificação':\n",
    "#                     self._handle_identificacao(session, value)\n",
    "#                 elif key == 'Atuação Profissional':\n",
    "#                     self._handle_atuacao_profissional(session, value)\n",
    "#                 elif key == 'Atuação Profissional':\n",
    "#                     self._handle_atuacao_profissional(session, value)                    \n",
    "#                 elif key == 'Produções':\n",
    "#                     self._handle_producoes(session, value)\n",
    "#                 elif isinstance(value, list) and not value:\n",
    "#                     # Ignore empty lists\n",
    "#                     pass\n",
    "#                 elif isinstance(value, dict):\n",
    "#                     if 'JCR2' in value:\n",
    "#                         # Ignore the 'JCR2' subdictionary\n",
    "#                         del value['JCR2']\n",
    "\n",
    "#                     self._persist_data(session, value)\n",
    "\n",
    "#         elif isinstance(data, list):  # Check if it's a list\n",
    "#             for item in data:\n",
    "#                 self._persist_data(session, item)  # Recurse on list items\n",
    "\n",
    "#         else:\n",
    "#             # Handle other data types (strings, numbers, etc.) or raise an error\n",
    "#             self.logger.warning(\"Unexpected data type: %s\", type(data))\n",
    "\n",
    "\n",
    "#     def _handle_identificacao(self, session, data):\n",
    "#         for item in data:\n",
    "#             if item['campo'] == 'ID Lattes':\n",
    "#                 node_id = item['valor']\n",
    "#                 node = self._get_or_create_node(session, 'Pesquisador', {'ID Lattes': node_id})\n",
    "#                 self._persist_other_properties(session, node, data)\n",
    "#             else:\n",
    "#                 node = self._get_or_create_node(session, 'Pesquisador', {data.items()})\n",
    "\n",
    "#     def _handle_atuacao_profissional(self, session, data):\n",
    "#         for item in data:\n",
    "#             node = self._create_node(session, 'AtuaçãoProfissional', item)\n",
    "\n",
    "#     def _handle_producoes(self, session, data):\n",
    "#         for production_type, production_data in data.items():\n",
    "#             if production_type == 'Artigos completos publicados em periódicos':\n",
    "#                 for article in production_data:\n",
    "#                     node = self._create_node(session, production_type, article)\n",
    "#             elif production_type.startswith('1.'):\n",
    "#                 for index, article in enumerate(production_data):\n",
    "#                     node = self._create_node(session, production_type, article)\n",
    "#                     node['OrdemCronológica'] = index + 1\n",
    "\n",
    "#     def _get_or_create_node(self, session, label, properties):\n",
    "#         node = session.run(\"MATCH (n: {label}) WHERE {properties} RETURN n\", {\"label\": label, \"properties\": properties}).single()\n",
    "\n",
    "#         if not node:\n",
    "#             node = session.run(\"CREATE (n: {label} {properties}) RETURN n\", {\"label\": label, \"properties\": properties}).single()[\"n\"]\n",
    "#             self._node_created_count += 1\n",
    "\n",
    "#         return node\n",
    "\n",
    "#     def _create_node(self, session, label, properties):\n",
    "#         node = session.run(\"CREATE (n: {label} {properties}) RETURN n\", {\"label\": label, \"properties\": properties}).single()[\"n\"]\n",
    "#         self._node_created_count += 1\n",
    "\n",
    "#         return node\n",
    "\n",
    "#     def _persist_other_properties(self, session, node, data):\n",
    "#         for key, value in data.items():\n",
    "#             if key not in ['campo', 'valor']:\n",
    "#                 node[key] = value  \n",
    "\n",
    "#     def _create_relationship(self, session, start_node, relationship_type, end_node, properties={}):\n",
    "#         session.run(\"MATCH (a), (b) WHERE ID(a) = {start_node_id} AND ID(b) = {end_node_id} CREATE (a)-[r:{type} {props}]->(b) RETURN r\", \n",
    "#                     {\"start_node_id\": id(start_node), \"end_node_id\": id(end_node), \"type\": relationship_type, \"props\": properties})\n",
    "#         self._relationship_created_count += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91b1a362",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tipos=[]\n",
    "# subtipos=[]\n",
    "# for dict_pesq in dict_list:\n",
    "#     # Avaliando elementos da lista de dicionários do arquivo JSON de entrada\n",
    "#     if isinstance(dict_pesq, dict):\n",
    "#         for key1,val1 in dict_pesq.items():\n",
    "#             if key1 not in tipos:\n",
    "#                 tipos.append(key1)            \n",
    "#             print(f'N01: Elementos armazenados em dicionário:')\n",
    "#             print(f'     {key2:25} | Tipo dos valores: {type(val2)}')\n",
    "#             print(f'       Conteúdo disponível nos valores do dicionário de Nível 01:')\n",
    "#             # Avaliando filhos de primeiro nível na hierarquia (Seções)\n",
    "#             if isinstance(val1, list):\n",
    "#                 print(f'N01: Elementos armazenados em lista:')\n",
    "#                 print(f'     Conteúdo disponível nos valores:')\n",
    "#                 print(f'       {[x for x in val1]}')\n",
    "#             elif isinstance(val1, dict):\n",
    "#                 for key2,val2 in val1.items():\n",
    "#                     if key2 not in subtipos:\n",
    "#                         subtipos.append(key2)\n",
    "#                     print(f'       Chave: {key2:25} | Tipo dos valores: {type(val2)}')\n",
    "#                     print(f'         Conteúdo disponível nos valores do dicionário de Nível 02:')\n",
    "#                     # Avaliando filhos de segundo nível na hierarquia (Tipos de Seções)\n",
    "#                     if isinstance(val2, dict):\n",
    "#                         for key3,val3 in val2.items():\n",
    "#                             if key3 not in tipos:\n",
    "#                                 print(f'         Chave: {key3:25} | Tipo dos valores: {type(val3)}')\n",
    "#                                 print(f'          Conteúdo disponível nos valores do dicionário de Nível 03:')\n",
    "#                                 # Avaliando filhos de terceiro nível na hierarquia (Ocorrências de Tipos de Seções)\n",
    "#                                 if isinstance(val3, dict):\n",
    "#                                     print(f'               Chave: {key3:25} | Tipo dos valores: {type(val3)}')\n",
    "#                                     print(f'                 Conteúdo disponível nos valores do dicionário de Nível 04:')\n",
    "#                                     # print(val3)\n",
    "#             else:\n",
    "#                 print(f'N01: Elementos armazenados em {type(val1)}')\n",
    "#     else:\n",
    "#         print('ERRO NA ESTRUTURA DO JSON!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bb43cde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Create a Neo4jDataPersister instance\n",
    "# data_persister = Neo4jDataPersister('neo4j://localhost:7687', 'neo4j', 'password')\n",
    "# filename = 'dict_list.json'\n",
    "# json_data, formatted_creation_date, formatted_modification_date, time_count, unit = jfm.load_from_json(os.path.join(folder_data_input,filename))\n",
    "# print(f\"\\n{len(dict_list)} currículos carregados na lista de dicionários '{filename}'\")\n",
    "\n",
    "# # Persist the data to Neo4j\n",
    "# data_persister.persist_data_from_json(json_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87596beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for pesq in json_data:\n",
    "#     print(len(pesq.get('Produções').keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6cede6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class ProjectsHandler:\n",
    "\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def consult_data_by_property(self, name, property_name):\n",
    "#         with self._driver.session() as session:\n",
    "#             result = session.run(f\"MATCH (p:Person {{name: $name}}) RETURN p.`{property_name}` as data\", name=name)\n",
    "#             record = result.single()\n",
    "#             return record['data'] if record else None\n",
    "\n",
    "#     def create_projects_relations(self, name):\n",
    "#         successful_creations = 0\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             # Process 'Atuação Profissional' data\n",
    "#             professional_data = self.consult_data_by_property(name, 'Atuação Profissional')\n",
    "#             if professional_data:\n",
    "#                 for institution_name, _ in json.loads(professional_data).items():\n",
    "#                     session.run(\"MERGE (i:Instituição {name: $institution_name})\", institution_name=institution_name)\n",
    "#                     print(f\"Institution node created/merged for: {institution_name}\")\n",
    "\n",
    "#                     session.run(\"MATCH (p:Person {name: $name}), (i:Instituição {name: $institution_name}) MERGE (p)-[:TEM]->(i)\", name=name, institution_name=institution_name)\n",
    "#                     print(f\"Relationship established between {name} and {institution_name}.\")\n",
    "\n",
    "#             # Process other dynamic nodes\n",
    "#             key_labels_to_check = ['Linhas de pesquisa', 'Projetos de pesquisa', 'Projetos de extensão', 'Projetos de desenvolvimento']\n",
    "#             for key in key_labels_to_check:\n",
    "#                 formatted_key = f\"`{key}`\"  # Wrap the key with backticks\n",
    "#                 project_data = self.consult_data_by_property(name, key)\n",
    "#                 if project_data:\n",
    "#                     for project_time, project_name in json.loads(project_data).items():\n",
    "#                         if project_name:  # to avoid empty names\n",
    "#                             session.run(f\"MERGE (p:{formatted_key} {{name: $project_name}})\", project_name=project_name)\n",
    "#                             print(f\"{key} node created/merged for: {project_name}\")\n",
    "\n",
    "#                             session.run(f\"MATCH (a:Person {{name: $name}}), (p:{formatted_key} {{name: $project_name}}) MERGE (a)-[:TEM]->(p)\", name=name, project_name=project_name)\n",
    "#                             print(f\"Relationship established between {name} and {project_name} ({key}).\")\n",
    "#                             successful_creations += 1\n",
    "#                 else:\n",
    "#                     print(f\"'{key}' data not found for {name}\")\n",
    "\n",
    "#         print(f\"{successful_creations} projetos atualizados com sucesso.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cef4303",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import json\n",
    "# import re\n",
    "# from neo4j import GraphDatabase\n",
    "\n",
    "# class ArticleHandler:\n",
    "\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def fetch_person_productions(self, name):\n",
    "#         with self._driver.session() as session:\n",
    "#             result = session.run(\"MATCH (p:Person {name: $name}) RETURN p.Produções as produções\", name=name)\n",
    "#             record = result.single()\n",
    "#             return record['produções'] if record else None\n",
    "\n",
    "#     def extract_article_info(self, input_str):\n",
    "#         # Encontre todas as abreviaturas de iniciais em maiúsculas e seus índices\n",
    "#         abbreviations = [(match.group(), match.start()) for match in re.finditer(r'\\b[A-Z]\\.', input_str)]\n",
    "\n",
    "#         # Encontre a posição da maior ocorrência de abreviaturas de iniciais, se houver\n",
    "#         if abbreviations:\n",
    "#             max_abbr_position = max(abbreviations, key=lambda x: x[1])\n",
    "\n",
    "#             # Encontre a primeira ocorrência de '. ' ou ' . ' após a maior ocorrência de abreviaturas de iniciais\n",
    "#             first_separator_candidates = [\n",
    "#                 input_str.find('. ', max_abbr_position[1] + 3),\n",
    "#                 input_str.find(' . ', max_abbr_position[1] + 3),\n",
    "#                 input_str.find('.. ')\n",
    "#             ]\n",
    "#             first_separator_candidates = [pos for pos in first_separator_candidates if pos != -1]\n",
    "\n",
    "#             if first_separator_candidates:\n",
    "#                 first_separator = min(first_separator_candidates)\n",
    "\n",
    "#                 # Encontre a primeira ocorrência de '. ' após o primeiro separador\n",
    "#                 second_separator = input_str.find('. ', first_separator + 2)\n",
    "\n",
    "#                 # Encontre a primeira ocorrência de ', ' após o segundo separador\n",
    "#                 third_separator = input_str.find(', ', second_separator + 2)\n",
    "#             else:\n",
    "#                 first_separator = second_separator = third_separator = -1\n",
    "#         else:\n",
    "#             first_separator = second_separator = third_separator = -1\n",
    "\n",
    "#         # Defina o padrão para encontrar \"p.\" e o conteúdo até a próxima vírgula\n",
    "#         pages_match = re.search(r' p\\.\\s*(.*?),', input_str)\n",
    "#         pages = pages_match.group(1) if pages_match else \"\"\n",
    "\n",
    "#         # Defina o padrão para encontrar \"v.\" e o conteúdo até a próxima vírgula\n",
    "#         volume_match = re.search(r' v\\.\\s*(.*?),', input_str)\n",
    "#         volume = volume_match.group(1) if volume_match else \"\"\n",
    "\n",
    "#         # Encontre a primeira ocorrência de um ano de quatro dígitos seguido de ponto final após o terceiro separador\n",
    "#         year_match = re.search(r' \\d{4}\\.', input_str[third_separator + 2:])\n",
    "#         year = year_match.group().strip('.').strip() if year_match else \"\"\n",
    "\n",
    "#         # Extraia os dados com base nas posições dos separadores\n",
    "#         authors = input_str[:first_separator].strip()\n",
    "#         title = input_str[first_separator + 2:second_separator].strip()\n",
    "#         journal = input_str[second_separator + 2:third_separator].strip()\n",
    "\n",
    "#         # Verifique se a lista de autores e o título não estão vazios\n",
    "#         if not authors or not title:\n",
    "#             return None  # Retorna None para indicar falha\n",
    "\n",
    "#         # Crie um dicionário com os dados extraídos\n",
    "#         article_info = {\n",
    "#             \"authors\": authors,\n",
    "#             \"title\": title,\n",
    "#             \"original_title\": journal,\n",
    "#             \"pages\": pages,\n",
    "#             \"volume\": volume,\n",
    "#             \"year\": year\n",
    "#         }\n",
    "\n",
    "#         return article_info\n",
    "    \n",
    "#     def deserialize_and_create_nodes(self, name):\n",
    "#         print(f\"Fetching 'Produções' data for {name}...\")\n",
    "#         productions_data = self.fetch_person_productions(name)\n",
    "        \n",
    "#         if not productions_data:\n",
    "#             print(f\"'Produções' data not found or empty for {name}.\")\n",
    "#             return\n",
    "\n",
    "#         print(f\"Attempting to deserialize 'Produções' data for {name}...\")\n",
    "#         try:\n",
    "#             productions_data = json.loads(productions_data)\n",
    "#         except json.JSONDecodeError as e:\n",
    "#             print(f\"Failed to deserialize 'Produções' data for {name}: {e}\")\n",
    "#             return\n",
    "\n",
    "#         successful_articles = 0\n",
    "#         unsuccessful_articles = []\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             print(f\"Processing 'Produção bibliográfica' for {name}...\")\n",
    "#             bibliographic_production = productions_data.get(\"Produção bibliográfica\", {})\n",
    "            \n",
    "#             if isinstance(bibliographic_production, str):\n",
    "#                 print(f\"Attempting to deserialize 'Produção bibliográfica' for {name}...\")\n",
    "#                 try:\n",
    "#                     bibliographic_production = json.loads(bibliographic_production)\n",
    "#                 except json.JSONDecodeError as e:\n",
    "#                     print(f\"Failed to deserialize 'Produção bibliográfica' for {name}: {e}\")\n",
    "#                     return\n",
    "\n",
    "#             articles = json.loads(bibliographic_production.get(\"Artigos completos publicados em periódicos\", \"{}\"))\n",
    "\n",
    "#             for _, article_str in articles.items():\n",
    "#                 article_details = self.extract_article_info(article_str)\n",
    "\n",
    "#                 # Vamos imprimir os detalhes de cada artigo e verificar se os autores estão presentes.\n",
    "#                 print(f\"Original Article: {article_str}\")\n",
    "#                 print(f\"Extracted Details: {article_details}\")\n",
    "\n",
    "#                 if article_details:\n",
    "#                     article_details[\"title\"] = article_details[\"title\"].strip()\n",
    "#                     article_details[\"original_title\"] = article_details[\"original_title\"].strip()\n",
    "\n",
    "#                     session.run(f\"MERGE (a:Artigo {{title: $title}}) SET a += $details\", title=article_details[\"title\"], details=article_details)\n",
    "#                     session.run(f\"MATCH (p:Person {{name: $name}}), (a:Artigo {{title: $title}}) MERGE (p)-[:PUBLICOU]->(a)\", name=name, title=article_details[\"title\"])\n",
    "#                     successful_articles += 1\n",
    "#                 else:\n",
    "#                     unsuccessful_articles.append(article_str)\n",
    "\n",
    "#         print(f\"Processed {successful_articles} articles successfully for {name}.\")\n",
    "\n",
    "#         if unsuccessful_articles:\n",
    "#             print(\"Failed to process the following articles:\")\n",
    "#             for article in unsuccessful_articles:\n",
    "#                 print(article)\n",
    "\n",
    "#     def process_articles(self, name):\n",
    "#         self.deserialize_and_create_nodes(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "395566b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class JcrHandler:\n",
    "#     def __init__(self, uri, user, password):\n",
    "#         self._driver = GraphDatabase.driver(uri, auth=(user, password))\n",
    "\n",
    "#     def close(self):\n",
    "#         self._driver.close()\n",
    "\n",
    "#     def _consultar_propriedades_jcr(self, tx, name):\n",
    "#         query = (\n",
    "#             \"MATCH (p:Person {name: $name})\"\n",
    "#             \"RETURN p.JCR AS jcr\"\n",
    "#         )\n",
    "#         result = tx.run(query, name=name)\n",
    "#         return [record[\"jcr\"] for record in result]\n",
    "   \n",
    "#     ## Versão para usar com criação de nós secundários retorna JSON\n",
    "#     def consultar_propriedades_jcr(self, name):\n",
    "#         with self._driver.session() as session:\n",
    "#             query = (\n",
    "#                 \"MATCH (p:Person {name: $name})\"\n",
    "#                 \"RETURN p.JCR AS jcr\"\n",
    "#             )\n",
    "#             result = session.run(query, name=name)\n",
    "#             jcr_data = result.single()[\"jcr\"]\n",
    "#             jcr_properties_list = json.loads(jcr_data)\n",
    "#             return jcr_properties_list\n",
    "\n",
    "#     @staticmethod\n",
    "#     def _convert_list_to_dict(lst):\n",
    "#         \"\"\"\n",
    "#         Converts a list into a dictionary with indices as keys.\n",
    "        \n",
    "#         Parameters:\n",
    "#         - lst: list, input list to be transformed.\n",
    "        \n",
    "#         Returns:\n",
    "#         - dict: Transformed dictionary.\n",
    "#         \"\"\"\n",
    "#         return {str(i): item for i, item in enumerate(lst)}\n",
    "    \n",
    "#     def create_person_with_jcr(self, name, jcr_properties):\n",
    "#         with self._driver.session() as session:\n",
    "#             session.write_transaction(self._create_person_with_jcr, name, jcr_properties)\n",
    "\n",
    "#     @staticmethod\n",
    "#     def _create_person_with_jcr(tx, name, jcr_properties):\n",
    "#         # Cria o nó Person\n",
    "#         person_query = (\n",
    "#             \"CREATE (p:Person {name: $name}) \"\n",
    "#             \"RETURN p\"\n",
    "#         )\n",
    "#         person_result = tx.run(person_query, name=name)\n",
    "#         person_node = person_result.single()[0]\n",
    "\n",
    "#         # Cria os nós secundários para cada valor único de data-issn\n",
    "#         data_issn_values = set(prop.get(\"data-issn\") for prop in jcr_properties)\n",
    "#         for data_issn in data_issn_values:\n",
    "#             if data_issn:\n",
    "#                 secondary_node_query = (\n",
    "#                     \"CREATE (s:SecondaryNode {data_issn: $data_issn}) \"\n",
    "#                     \"RETURN s\"\n",
    "#                 )\n",
    "#                 tx.run(secondary_node_query, data_issn=data_issn)\n",
    "\n",
    "#                 # Cria a relação entre o nó Person e o nó secundário\n",
    "#                 relation_query = (\n",
    "#                     \"MATCH (p:Person {name: $name}), (s:SecondaryNode {data_issn: $data_issn}) \"\n",
    "#                     \"CREATE (p)-[:HAS_JCR]->(s)\"\n",
    "#                 )\n",
    "#                 tx.run(relation_query, name=name, data_issn=data_issn)\n",
    "\n",
    "#     def createJournalsNodes(self, name):\n",
    "#         # Get JCR properties\n",
    "#         jcr_properties = self.consultar_propriedades_jcr(name)\n",
    "\n",
    "#         # Convert the serialized JSON strings back into dictionaries\n",
    "#         deserialized_jcr_properties = [json.loads(prop) for prop in jcr_properties.values()]\n",
    "\n",
    "#         # Inform the user about the total number of JCR property entries\n",
    "#         total_entries = len(deserialized_jcr_properties)\n",
    "#         print(f\"Read {total_entries} entries from JCR properties of Person '{name}'.\")\n",
    "\n",
    "#         # Extract relevant journal properties and their count\n",
    "#         journal_counts = Counter(prop.get(\"data-issn\") for prop in deserialized_jcr_properties)\n",
    "        \n",
    "#         # Number of unique ISSNs\n",
    "#         unique_issns = len(journal_counts)\n",
    "#         print(f\"Identified {unique_issns} unique ISSN values.\")\n",
    "\n",
    "#         null_count = journal_counts.pop(None, 0)  # Remove None (null) ISSN and get its count\n",
    "#         null_count += journal_counts.pop(\"NULL\", 0)  # Also account for \"NULL\" as a string\n",
    "\n",
    "#         # Counters for journals\n",
    "#         successful_journal_creations = 0\n",
    "\n",
    "#         with self._driver.session() as session:\n",
    "#             for data_issn, count in journal_counts.items():\n",
    "#                 if data_issn and data_issn != \"NULL\":\n",
    "#                     representative_entry = next(prop for prop in deserialized_jcr_properties if prop.get(\"data-issn\") == data_issn)\n",
    "#                     journal_name = representative_entry.get(\"original_title\")\n",
    "#                     fator_impacto = representative_entry.get(\"impact-factor\")\n",
    "#                     jcr_year = representative_entry.get(\"jcr-year\")\n",
    "\n",
    "#                     # Create or merge the Journal node\n",
    "#                     journal_node_query = (\n",
    "#                         \"MERGE (j:Revistas {ISSN: $data_issn}) \"\n",
    "#                         \"ON CREATE SET j.name = $journal_name, j.FatorImpacto = $impact_factor, j.JCRYear = $jcr_year \"  # Corrected this line\n",
    "#                         \"RETURN j\"\n",
    "#                     )\n",
    "#                     session.run(journal_node_query, data_issn=data_issn, journal_name=journal_name, impact_factor=fator_impacto, jcr_year=jcr_year)  # And this line\n",
    "\n",
    "#                     # Create or update the \"PUBLICOU_EM\" relationship\n",
    "#                     relation_query = (\n",
    "#                         \"MATCH (p:Person {name: $name}), (j:Revistas {ISSN: $data_issn}) \"  # corrected this line\n",
    "#                         \"MERGE (p)-[r:PUBLICOU_EM]->(j) \"\n",
    "#                         \"ON CREATE SET r.QuantidadePublicações = $count \"\n",
    "#                         \"ON MATCH SET r.QuantidadePublicações = r.QuantidadePublicações + $count\"\n",
    "#                     )\n",
    "#                     session.run(relation_query, name=name, data_issn=data_issn, count=count)\n",
    "                    \n",
    "#                     successful_journal_creations += 1\n",
    "                \n",
    "#                 if null_count:\n",
    "#                     # For example, to print the count:\n",
    "#                     pass\n",
    "        \n",
    "#         # Inform the user about journals\n",
    "#         print(f\"{successful_journal_creations} Revistas adicionadas com sucesso.\")\n",
    "#         print(f\"{null_count} Revistas não foram criadas por terem valor NULL de ISSN.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "368a2be6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pip install pdfkit\n",
    "# %pip install unicodedata2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e52e23b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import pdfkit\n",
    "# import unidecode\n",
    "# import unicodedata\n",
    "# import pandas as pd\n",
    "\n",
    "# # Função para remover acentos usando unicodedata\n",
    "# def remover_acentos_unicodedata(texto):\n",
    "#     texto_sem_acentos = ''.join(c for c in unicodedata.normalize('NFD', texto)\n",
    "#                                 if unicodedata.category(c) != 'Mn')\n",
    "#     return texto_sem_acentos\n",
    "\n",
    "# # Função para remover acentos usando unicode    \n",
    "# def remover_acentos(texto):\n",
    "#   return unidecode.unidecode(texto)\n",
    "\n",
    "# def substituir_abreviaturas(texto):\n",
    "#     padrao = re.compile(r\"\\bDr\\.\")\n",
    "#     return padrao.sub(lambda m: m.group().replace(\".\", \"\"), texto)\n",
    "\n",
    "# def substituir_iniciais(texto):\n",
    "#     padrao = re.compile(r\"\\b[A-Z]\\.\")  # Expressão regular para qualquer letra maiúscula seguida de ponto\n",
    "#     return padrao.sub(lambda m: m.group()[:-1], texto)  # Remove o ponto da inicial\n",
    "\n",
    "# # Define a função para verificar se a string contém un dos termos da lista de detecção (case insensitive)\n",
    "# def contem_fiocruz(instituicao):\n",
    "#     termos = ['fiocruz', 'fundação oswaldo cruz']\n",
    "#     for termo in termos:\n",
    "#         if termo.lower() in instituicao.lower():\n",
    "#             return 'interno'\n",
    "#     return 'externo'\n",
    "\n",
    "# def organizar_orientacoes_geral(dict_list_docents):\n",
    "#     tipos = []\n",
    "#     orientacoes_set = set()\n",
    "#     orientacoes_lista = []\n",
    "\n",
    "#     ano = None\n",
    "#     papel = None\n",
    "#     orientando = None\n",
    "#     instituicao = ''\n",
    "\n",
    "#     for curriculo in dict_list_docents:\n",
    "#         nome = curriculo.get('Identificação').get('Nome')\n",
    "#         orientacoes_curriculo = curriculo.get('Orientações')\n",
    "#         if orientacoes_curriculo:\n",
    "#             for secao in orientacoes_curriculo: # Itera sobre as seções principais\n",
    "#                 for subsecao in secao['subsecoes']:\n",
    "#                     subsec_name = subsecao['nome']\n",
    "#                     if 'concluídas' in subsec_name:\n",
    "#                         status = 'concluídas'\n",
    "#                     else:\n",
    "#                         status = 'em andamento'\n",
    "#                     for orientacao in subsecao['orientacoes']:\n",
    "#                         tipo = orientacao['tipo']\n",
    "#                         detalhes = orientacao['detalhes']\n",
    "\n",
    "#                         detalhes = substituir_iniciais(detalhes)\n",
    "#                         detalhes = substituir_abreviaturas(detalhes)\n",
    "#                         if tipo == 'Supervisão de pós-doutorado':\n",
    "#                             orientando = detalhes.split('. ')[0].title()\n",
    "#                             ano = detalhes.split('. ')[1].replace('Início: ', '')\n",
    "#                             papel = 'supervisor'\n",
    "#                         else:\n",
    "#                             orientando = detalhes.split('. ')[0].title()\n",
    "#                             titulo = detalhes.split('. ')[1]\n",
    "#                             ano = detalhes.split('. ')[2].replace('Início: ', '')\n",
    "#                             try:\n",
    "#                                 hifens = len(detalhes.split('. ')[-2].split('-'))\n",
    "#                                 inst = detalhes.split('. ')[-2].split('-')[-1].strip()\n",
    "#                                 if len(inst) == 2:\n",
    "#                                     instituicao = detalhes.split('. ')[-3].split('-')[1].strip().replace('Ã¡', 'á').replace('Ã§Ã£', 'çã').replace('(', '').replace(').', '').replace(')', '')\n",
    "#                                 elif len(inst) == 4:\n",
    "#                                     instituicao = detalhes.split('. ')[-2].split('-')[-1].strip().replace('Ã¡', 'á').replace('Ã§Ã£', 'çã').replace('(', '').replace(').', '').replace(')', '')\n",
    "#                                 # elif len(inst) != 2 and hifens > 1:\n",
    "#                                 #   instituicao = detalhes.split('. ')[-2].split('-')[-1].strip().replace('Ã¡', 'á').replace('Ã§Ã£', 'çã').replace('(', '').replace(').', '').replace(')', '')\n",
    "#                                 else:\n",
    "#                                     instituicao = detalhes.split('. ')[-2].split('-')[-1].strip().replace('Ã¡', 'á').replace('Ã§Ã£', 'çã').replace('(', '').replace(').', '').replace(')', '')\n",
    "#                             except:\n",
    "#                                 instituicao = detalhes.split('. ')[-2].strip().replace('Ã¡', 'á').replace('Ã§Ã£', 'çã').replace('(', '').replace(').', '').replace(')', '')\n",
    "#                             papel = detalhes.split('. ')[-1].split(':')[0].strip().replace('(', '').replace(').', '').replace(')', '')\n",
    "\n",
    "#                         if len(ano) != 4:\n",
    "#                             resultado = re.search(r\"\\d{4}\", detalhes)\n",
    "#                             if resultado:\n",
    "#                                 ano = resultado.group().strip()\n",
    "\n",
    "#                         if tipo not in tipos:\n",
    "#                             tipos.append(tipo)\n",
    "\n",
    "#                         padrao = re.compile(r\" Associação| Avaliação Dos| Síndrome Da| Prevalência| Atendimento| Avaliação Da| Avaliação| Atenção| Uso Farmacológico| Assinaturas| : ?Estratégias| Construção| Caracterização| Efeitos\")\n",
    "\n",
    "#                         if len(orientando.split(' ')) > 5:\n",
    "#                             orientando = padrao.sub(\"\", orientando)\n",
    "\n",
    "#                         # Verifica se a instituição foi extraída corretamente, se não, atribui 'Não Informada'\n",
    "#                         if not instituicao:\n",
    "#                             instituicao = 'Não Informada'\n",
    "\n",
    "#                         # Cria uma tupla com as informações da orientação\n",
    "#                         orientacao_info = (nome, papel, ano, orientando, instituicao, tipo, status)\n",
    "\n",
    "#                         # Adiciona a orientação à lista apenas se for única\n",
    "#                         if orientacao_info not in orientacoes_set:\n",
    "#                             orientacoes_set.add(orientacao_info)\n",
    "#                             orientacoes_lista.append({\n",
    "#                                 'Docente': nome,\n",
    "#                                 'papel': papel,\n",
    "#                                 'ano': ano,\n",
    "#                                 'orientando': orientando,\n",
    "#                                 'instituicao': instituicao,\n",
    "#                                 'tipo': tipo,\n",
    "#                                 'status': status\n",
    "#                             })\n",
    "\n",
    "#     # Converte o conjunto de orientações de volta para uma lista\n",
    "#     orientacoes_lista = list({'Docente': nome, 'papel': papel, 'ano': ano, 'orientando': orientando, 'instituicao': instituicao, 'tipo': tipo, 'status': status}\n",
    "#         for (nome, papel, ano, orientando, instituicao, tipo, status) in orientacoes_set\n",
    "#     )\n",
    "\n",
    "#     return orientacoes_lista\n",
    "\n",
    "# def criar_dataframe_contagens(orientacoes_lista, ano_inicio, ano_final, tipos_aceitaveis):\n",
    "#     # Cria um DataFrame a partir da lista de orientações\n",
    "#     df_orientacoes = pd.DataFrame(orientacoes_lista)\n",
    "\n",
    "#     # Filter the DataFrame based on 'Ano' and 'Tipo', criando uma cópia explícita\n",
    "#     df_orientacoes_filtrado = df_orientacoes[\n",
    "#         (df_orientacoes['ano'].astype(int) >= ano_inicio) &\n",
    "#         (df_orientacoes['ano'].astype(int) <= ano_final) &\n",
    "#         (df_orientacoes['tipo'].isin(tipos_aceitaveis))\n",
    "#     ].copy()\n",
    "\n",
    "#     # Cria a coluna 'Interno Fiocruz' usando .loc para evitar o SettingWithCopyWarning\n",
    "#     df_orientacoes_filtrado.loc[:, 'Interno Fiocruz'] = df_orientacoes_filtrado['instituicao'].astype(str).apply(contem_fiocruz)\n",
    "\n",
    "#     # Calcula o total de orientações 'interno', incluindo a coluna 'status'\n",
    "#     total_interno = df_orientacoes_filtrado[df_orientacoes_filtrado['Interno Fiocruz'] == 'interno'].groupby(['Docente', 'status']).size().reset_index(name='Interno Fiocruz')\n",
    "\n",
    "#     # Calcula o total de orientações 'externo', incluindo a coluna 'status'\n",
    "#     total_externo = df_orientacoes_filtrado[df_orientacoes_filtrado['Interno Fiocruz'] == 'externo'].groupby(['Docente', 'status']).size().reset_index(name='Externo à Fiocruz')\n",
    "\n",
    "#     # Faz o merge dos resultados usando um outer join, incluindo a coluna 'status'\n",
    "#     resultado_final = total_interno.merge(total_externo, on=['Docente', 'status'], how='outer')\n",
    "\n",
    "#     # Ordena o DataFrame\n",
    "#     resultado_final = resultado_final.sort_values('Docente')\n",
    "\n",
    "#     # Preenche os valores ausentes com zero\n",
    "#     resultado_final = resultado_final.fillna(0)\n",
    "\n",
    "#     # Redefine o índice para ter 'Docente' como uma coluna\n",
    "#     resultado_final = resultado_final.reset_index()\n",
    "\n",
    "#     # Reordena as colunas\n",
    "#     cols = ['Docente', 'status', 'Interno Fiocruz', 'Externo à Fiocruz']\n",
    "#     resultado_final = resultado_final[cols]\n",
    "\n",
    "#     return resultado_final\n",
    "\n",
    "# # Função para gerar o relatório em HTML\n",
    "# def generate_html_report(orientacoes_lista):\n",
    "#     # Cria a estrutura da tabela HTML, incluindo os novos cabeçalhos\n",
    "#     html_content = \"\"\"\n",
    "#     <!DOCTYPE html>\n",
    "#     <html>\n",
    "#     <head>\n",
    "#     <style>\n",
    "#     table {\n",
    "#       font-family: arial, sans-serif;\n",
    "#       border-collapse: collapse;\n",
    "#       width: 100%;\n",
    "#     }\n",
    "\n",
    "#     td, th {\n",
    "#       border: 1px solid #dddddd;\n",
    "#       text-align: left;\n",
    "#       padding: 8px;\n",
    "#     }\n",
    "\n",
    "#     tr:nth-child(even) {\n",
    "#       background-color: #dddddd;\n",
    "#     }\n",
    "#     </style>\n",
    "#     </head>\n",
    "#     <body> \n",
    "\n",
    "\n",
    "#     <h2>Relatório de Orientações Concluídas</h2>\n",
    "\n",
    "#     <table>\n",
    "#       <tr>\n",
    "#         <th>Docente</th>\n",
    "#         <th>Papel</th>\n",
    "#         <th>Ano</th>\n",
    "#         <th>Orientando</th>\n",
    "#         <th>Instituição</th>\n",
    "#         <th>Tipo de Orientação</th> \n",
    "#         <th>Status</th>            \n",
    "#       </tr>\n",
    "#     \"\"\"\n",
    "\n",
    "#     # Itera sobre a lista de dicionários e extrai as informações relevantes\n",
    "#     for orientacao in orientacoes_lista:\n",
    "#         docente = orientacao.get('Docente', '')\n",
    "#         papel = orientacao.get('papel', '')\n",
    "#         ano = orientacao.get('ano', '')\n",
    "#         orientando = orientacao.get('orientando', '')\n",
    "#         instituicao = orientacao.get('instituicao', '')\n",
    "#         tipo = orientacao.get('tipo', '')       \n",
    "#         status = orientacao.get('status', '')   \n",
    "\n",
    "#         # Popula a tabela HTML com os dados extraídos, incluindo as novas células\n",
    "#         html_content += f\"\"\"\n",
    "#         <tr>\n",
    "#             <td>{docente}</td>\n",
    "#             <td>{papel}</td>\n",
    "#             <td>{ano}</td>\n",
    "#             <td>{orientando}</td>\n",
    "#             <td>{instituicao}</td>\n",
    "#             <td>{tipo}</td>          \n",
    "#             <td>{status}</td>        \n",
    "#         </tr>\n",
    "#         \"\"\"\n",
    "\n",
    "#     # Fecha a tabela HTML\n",
    "#     html_content += \"\"\"\n",
    "#     </table>\n",
    "\n",
    "#     </body>\n",
    "#     </html>\n",
    "#     \"\"\"\n",
    "\n",
    "#     # try:\n",
    "#     #     # Tenta importar a biblioteca pdfkit\n",
    "#     #     import pdfkit\n",
    "\n",
    "#     #     # Converte o conteúdo HTML para PDF usando pdfkit\n",
    "#     #     pdfkit.from_string(html_content, 'relatorio_orientacoes.pdf')\n",
    "\n",
    "#     #     # Imprime uma mensagem de sucesso\n",
    "#     #     print(\"Relatório em PDF gerado com sucesso: relatorio_orientacoes.pdf\")\n",
    "\n",
    "#     # except ImportError:\n",
    "#     #     # Lidar com o caso em que pdfkit não está instalado\n",
    "#     #     print(\"Erro: A biblioteca pdfkit não está instalada. Instale-a usando o comando 'pip install pdfkit' para gerar o relatório em PDF.\")\n",
    "    \n",
    "#     return html_content\n",
    "\n",
    "# # Função para gerar o relatório em PDF\n",
    "# def generate_pdf_report(html_content):\n",
    "#     pdfkit.from_string(html_content, 'relatorio_orientacoes.pdf')\n",
    "#     print(\"Relatório em PDF gerado com sucesso: relatorio_orientacoes.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d765e608",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Verificar as chaves disponíveis em cada dicionário\n",
    "# for i,j in enumerate(dict_list_docents):\n",
    "#     print(f'{i:02} {j.keys()}')\n",
    "\n",
    "# [x.get('Produções') for x in dict_list_docents][3].keys()\n",
    "\n",
    "# Ver dados da planilha da plataforma Sucupira com dados de todo Qualis Periódicos\n",
    "# fonte_planilha = 'classificações_publicadas_todas_as_areas_avaliacao1672761192111.xlsx'\n",
    "# dados_qualis = pd.read_excel(os.path.join(LattesScraper.find_repo_root(),'_data','in_xls',fonte_planilha))\n",
    "# dados_qualis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f4fe327",
   "metadata": {},
   "source": [
    "## Teste extrair homônimos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5e1ea36",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Teste de extração para homônimos\n",
    "# t1 = time.time()\n",
    "# lista_homonimos = [\n",
    "#     'Tania Maria Alves de Almeida',\n",
    "#     'Rodrigo Corrêa de Oliveira',\n",
    "# ]\n",
    "\n",
    "# scraper = LattesScraper(termos_busca, 'bolt://localhost:7687', 'neo4j', 'password', only_doctors=True)\n",
    "# dom_dict_homonimos = scraper.scrape(lista_homonimos, termos_busca)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29f73c80",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_geral_orientacoes, df_geral_orientacoes_ano = atualizador.apurar_orientacoes(dict_list_docents, ano_inicio, ano_final)\n",
    "df_geral_orientacoes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9694e343",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_geral_orientacoes_ano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d86baae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_geral_orientacoes_old, df_geral_orientacoes_ano_old = atualizador.apurar_orientacoes_old(dict_list_docents, ano_inicio, ano_final)\n",
    "\n",
    "df_geral_orientacoes_old"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abb4ecfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_geral_orientacoes_ano_old"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "399964df",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Pontuação dos Orientadores por artigos publicados ponderados pelo JCR no período {ano_inicio} a {ano_final}')\n",
    "df_artigos_orientadores = atualizador.apurar_jcr_orientadores(df_resultado, orientadores)\n",
    "df_artigos_orientadores"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "197d8f220c237ea2269a397bcc5571d13b6ee9614ab9ae87aa2d290b25dc373b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}