.

.gitattributes

@@ -0,0 +1,3 @@
+*.pdf filter=lfs diff=lfs merge=lfs -text
+*.faiss filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

sandbox/escala_de_lawton.pdf → CIF/ListaCIF.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1834624e8b2e6f4799445f2314177945c7064e86649d6e3efd70341f14924b4e
-size 2244469
+oid sha256:2add1fa3846d7e828037251381010d43e9f349d9ed86214f77986672baf85f9c
+size 311858

pages/README.md

@@ -0,0 +1,13 @@
+# pages/
+
+Páginas do aplicativo. O conceito geral é dividir a lógica de cada página em:
+
+- `view.py`: Elementos visuais e sua lógica de mudança de estado.
+- `strings.py`: Textos utilizados. Seu isolamento facilita manutenção e permite adaptações de idiomas (futuras).
+- `scripts.py`: Lógica menor para comportamento da página entre seus componentes e códigos mais robustos em utils.
+
+São páginas:
+
+- `about`: Página que aborda a Classificação Internacional de Funcionalidade, Incapacidade e Saúde (CIF) e a proposta do projeto.
+- `main`: Página principal, trata do envio de textos, recebimento da resposta da IA e relatório da vinculação gerada.
+- `feedback`: Página responsável por receber comentários e armazená-los em uma planilha google para análise.

pages/about/strings.py

@@ -1,3 +1,4 @@
+# pages/about/strings.py
 STRINGS = {
     "ABOUT_TITLE": "# CIFLink 2.0",
     # Descrição do aplicativo

pages/about/view.py

@@ -1,3 +1,4 @@
+# pages/about/view.py
 import gradio as gr
 import os
 
@@ -34,10 +35,6 @@ with gr.Blocks() as interface:
     gr.Markdown(STRINGS["SECTION_REFERENCES"])
     gr.Markdown(STRINGS["SECTION_REFERENCES_LINKS"])
     gr.Markdown(STRINGS["SECTION_REFERENCES_LIST"])
-
-    
-
-
-
+ 
 if __name__ == "__main__":
     interface.launch()

pages/feedback/scripts.py

@@ -1,3 +1,4 @@
+# pages/feedback/scripts.py
 import datetime
 import gspread
 import os

pages/feedback/strings.py

@@ -1,3 +1,4 @@
+# pages/feedback/strings.py
 STRINGS = {
     "TITLE": "# Contate-nos",
     "SUBTITLE": "Ajude-nos a melhorar a aplicação enviando seu feedback. Seu comentário é muito importante para nós!",

pages/feedback/view.py

@@ -1,3 +1,4 @@
+# pages/feedback/view.py
 import gradio as gr
 
 from .scripts import submit_feedback_and_handle_errors

pages/main/scripts.py

@@ -1,18 +1,15 @@
+# pages/main/scripts.py
 import faiss
 import gradio as gr
 from typing import Any, Generator
-from sentence_transformers import SentenceTransformer
-from utils.rag_llm_response import (
-    generate_response_with_llm,
-)  # A função unificada agora trata as estratégias de RAG e LLM
-from utils.phrase_extractor import process_file_content
-
-# from utils.report_creation import generate_report
-from utils.api_gemini import api_generate
+#from sentence_transformers import SentenceTransformer
+#from utils.rag_llm_response import generate_response_with_llm # A função unificada agora trata as estratégias de RAG e LLM
+#from utils.phrase_extractor import process_file_content
+#from utils.report_creation import generate_report
+from utils.apis.gemini import api_generate
 from .strings import STRINGS
-
-# DEPRECATED: A função volta com a consolidação de um futuro OCR.
-# def extract_phrases_from_gradio_file(gradio_file: gr.File) -> gr.Textbox:
+# DEPRECATED: A função era um protótipo para criação de Contexto RAG.
+#def extract_phrases_from_gradio_file(gradio_file: gr.File) -> gr.Textbox:
 #    """
 #    Utilizes the 'process_file' function from 'utils.phrase_extractor' to read the
 #    file content and extract phrases, returning them as a text block for Gradio.
@@ -23,24 +20,22 @@ from .strings import STRINGS
 #    try:
 #        # Chama a função unificada de processamento de arquivo que retorna uma lista de frases
 #        phrases = process_file_content(gradio_file.name)
-#
+#        
 #        phrases_text = "\n".join(phrases)
 #        return gr.Textbox(value=phrases_text, placeholder=STRINGS["TEXT_INPUT_PLACEHOLDER_LOADED"])
 #    except Exception as e:
 #        return gr.Textbox(value=f"Error: {e}", placeholder=STRINGS["TEXT_INPUT_PLACER_EMPTY"])
 
-
 # DEPRECATED: A função volta com a consolidação de um futuro RAG.
-def process_phrases_with_rag_llm(
-    input_phrases_text: str, rag_docs: list[str], rag_index: faiss.Index, rag_embedder: SentenceTransformer
-) -> Generator[tuple[gr.Textbox, gr.Textbox, gr.Tabs, gr.TabItem], None, None]:
+'''
+def process_phrases_with_rag_llm(input_phrases_text: str, rag_docs:list[str], rag_index:faiss.Index, rag_embedder:SentenceTransformer) -> Generator[tuple[gr.Textbox, gr.Textbox, gr.Tabs, gr.TabItem]]:
     """
     Receives a block of text (phrases separated by newlines) and processes it
     with the RAG+LLM API (`res_generate_API`) using a multiple-context strategy.
     Returns a status textbox, a formatted responses textbox, and updates tabs to switch to the results tab.
     """
-    print(f'Processando o bloco de frases para geração de resposta: "{input_phrases_text[:100]}..."')
-    current_symbol = " ♾️"  # Emojis para indicar status de processamento e sucesso
+    print(f"Processando o bloco de frases para geração de resposta: \"{input_phrases_text[:100]}...\"")
+    current_symbol = " ♾️"  # Emojis para indicar status de processamento e sucesso    
 
     # --- Ação 1: Mudar de aba IMEDIATAMENTE e mostrar mensagem de processamento ---
     # O 'yield' envia: (Status, Resultado, Tabs)
@@ -48,9 +43,9 @@ def process_phrases_with_rag_llm(
         gr.update(value=STRINGS["TXTBOX_STATUS_IDLE"], interactive=False),
         gr.update(value="", interactive=False),
         gr.update(selected=1),
-        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True),
-    )
-
+        gr.update(label=STRINGS["TAB_1_TITLE"]+current_symbol, interactive=True)
+        )
+    
     # time.sleep(1)  # Simula um pequeno atraso para processamento
 
     try:
@@ -62,16 +57,16 @@ def process_phrases_with_rag_llm(
             documents=rag_docs,
             index=rag_index,
             embedder=rag_embedder,
-            llm_choice="gemini",  # ou 'ollama', conforme a necessidade
-            rag_strategy="multiple",  # A chave para usar a busca por múltiplos contextos
+            llm_choice='gemini', # ou 'ollama', conforme a necessidade
+            rag_strategy='multiple' # A chave para usar a busca por múltiplos contextos
         )
 
-        #        with open("./sandbox/respostateste.txt", "r", encoding="utf-8") as arquivo:
-        #            llm_response = arquivo.read() #TODO: Test Only
+#        with open("./sandbox/respostateste.txt", "r", encoding="utf-8") as arquivo:
+#            llm_response = arquivo.read() #TODO: Test Only
 
         status_message = STRINGS["TXTBOX_STATUS_OK"]
         formatted_output = f"--- Resposta Fornecida pela LLM ---\n{llm_response}\n"
-        current_symbol = " ✅"
+        current_symbol = " ✅" 
 
     except Exception as e:
         status_message = STRINGS["TXTBOX_STATUS_ERROR"]
@@ -84,64 +79,78 @@ def process_phrases_with_rag_llm(
         gr.update(value=status_message, interactive=False),
         gr.update(value=formatted_output, interactive=False),
         gr.update(),
-        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True),
+        gr.update(label=STRINGS["TAB_1_TITLE"]+current_symbol, interactive=True)
     )
+'''
+def process_inputs_to_api(
+    input_text: str,
+    input_file: Any  # Objeto de arquivo do Gradio (ex: tempfile._TemporaryFileWrapper)
+) -> Generator[tuple, None, None]:
+    """
+    Processa a entrada do usuário (texto ou arquivo) com a API do Gemini.
 
+    Esta função serve como o handler para a interface Gradio. Ela implementa a
+    lógica XOR para garantir que apenas uma forma de entrada seja fornecida,
+    atualiza a UI com o status e exibe o resultado da análise.
 
-def process_phrases_with_api_llm(
-    input_phrases_text: str,
-) -> Generator[tuple[gr.Textbox, gr.Textbox, gr.Tabs, gr.TabItem], None, None]:
-    """
-    Receives a block of text and processes it
-    with the API (`res_generate_API`).
-    Returns a status textbox, a formatted responses textbox, and updates tabs to switch to the results tab.
+    Args:
+        input_text: O conteúdo do componente gr.Textbox.
+        input_file: O objeto do componente gr.File. É None se nenhum arquivo for carregado.
+
+    Yields:
+        Atualizações para os componentes da interface do Gradio.
     """
-    print(f'Processando o bloco de frases para geração de resposta: "{input_phrases_text[:100]}..."')
-    current_symbol = " ♾️"  # Emojis para indicar status de processamento e sucesso
+    current_symbol = " ♾️"  # Símbolo de processamento
+    formatted_output = ""
+    status_message = STRINGS["TXTBOX_STATUS_IDLE"]
 
-    # --- Ação 1: Mudar de aba IMEDIATAMENTE e mostrar mensagem de processamento ---
-    # O 'yield' envia: (Status, Resultado, Tabs)
+    # --- Ação 1: Atualiza a UI para mostrar que o processamento começou ---
     yield (
-        gr.update(value=STRINGS["TXTBOX_STATUS_IDLE"], interactive=False),
+        gr.update(value=status_message, interactive=False),
         gr.update(value="", interactive=False),
-        gr.update(selected=1),
-        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True),
+        gr.update(selected=1),  # Muda para a aba de resultados
+        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True)
     )
 
-    # time.sleep(1)  # Simula um pequeno atraso para processamento
-
     try:
-        # Chama a função unificada de geração de resposta, especificando a estratégia RAG
-        # O LLM então usará os múltiplos contextos recuperados para gerar uma única resposta consolidada.
-
-        #        llm_response = generate_response_with_llm(
-        #            input_phrase=input_phrases_text,
-        #            documents=rag_docs,
-        #            index=rag_index,
-        #            embedder=rag_embedder,
-        #            llm_choice='gemini', # ou 'ollama', conforme a necessidade
-        #            rag_strategy='multiple' # A chave para usar a busca por múltiplos contextos
-        #        )
-
-        #        with open("./sandbox/respostateste.txt", "r", encoding="utf-8") as arquivo:
-        #            llm_response = arquivo.read() #TEST: Test Only
-
-        llm_response = api_generate(user_input=input_phrases_text)
+        # --- Ação 2: Lógica de validação XOR para as entradas da UI ---
+        texto_fornecido = bool(input_text and input_text.strip())
+        arquivo_fornecido = input_file is not None
+
+        if texto_fornecido and arquivo_fornecido:
+            raise ValueError("Por favor, forneça texto OU um arquivo PDF, não ambos.")
+        
+        if not texto_fornecido and not arquivo_fornecido:
+            raise ValueError("Nenhuma entrada fornecida. Por favor, digite um texto ou faça o upload de um arquivo.")
+
+        # --- Ação 3: Chama o backend com o parâmetro correto ---
+        params_para_api = {}
+        if texto_fornecido:
+            print(f"Processando via texto: \"{input_text[:100]}...\"")
+            params_para_api['input_text'] = input_text
+        elif arquivo_fornecido:
+            # O objeto do Gradio tem um atributo .name que contém o caminho temporário do arquivo
+            print(f"Processando via arquivo: {input_file.name}")
+            params_para_api['input_file'] = input_file.name
+
+        # Chama a função de backend com os parâmetros corretos
+        llm_response = api_generate(**params_para_api)
 
         status_message = STRINGS["TXTBOX_STATUS_OK"]
         formatted_output = f"--- Resposta Fornecida pela LLM ---\n{llm_response}\n"
         current_symbol = " ✅"
 
     except Exception as e:
+        # Captura qualquer erro (de validação ou da API) e o exibe na UI
         status_message = STRINGS["TXTBOX_STATUS_ERROR"]
-        formatted_output = f"\n{STRINGS['--- Erro ---']}\nDetalhes: {e}"
+        formatted_output = f"\n--- Erro ao Processar ---\nDetalhes: {e}"
         current_symbol = " ⚠️"
+        print(f"ERRO na interface Gradio: {e}") # Loga o erro completo no console
 
-    # --- Ação 3: Retornar o resultado final e o status ---
-    # A aba já está selecionada, então gr.Tabs() aqui apenas satisfaz a assinatura e mantém a aba atual.
+    # --- Ação Final: Retorna o resultado (sucesso ou erro) para a UI ---
     yield (
         gr.update(value=status_message, interactive=False),
-        gr.update(value=formatted_output, interactive=False),
+        gr.update(value=formatted_output, interactive=True), # Permite copiar o resultado
         gr.update(),
-        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True),
-    )
+        gr.update(label=STRINGS["TAB_1_TITLE"] + current_symbol, interactive=True)
+    )

pages/main/strings.py

@@ -1,9 +1,10 @@
+# pages/main/strings.py
 STRINGS = {
     "APP_TITLE": "Sistema para Vinculação CIF de Frases",
     "APP_DESCRIPTION": "Insira frases, obtenha as vinculações dos conceitos significativos à CIF feitas por IA.",
     # tab id = 0
-    "TAB_0_TITLE": "Entrada de Frases via Arquivos",
-    "TAB_0_SUBTITLE": "## 📝 Passo 1: Forneça as Frases",
+    "TAB_0_TITLE": "Entrada de Texto",
+    "TAB_0_SUBTITLE": "## 📝 Passo 1: Forneça o Texto",
     # tab id = 1    
     "TAB_1_TITLE": "Resultados da Vinculação",
     "TAB_1_SUBTITLE": "## 🤖 Passo 2: Visualize os Resultados",
@@ -19,6 +20,8 @@ STRINGS = {
     # button_process_input
     "BTN_PROCESS_INPUT_LABEL_DISABLED": "Aguardando Frases...",
     "BTN_PROCESS_INPUT_LABEL_ENABLED": "Vincular Frases",
+    "BTN_PROCESS_FILE_LABEL": "Vincular por Documento 📙",
+    "BTN_PROCESS_TEXT_LABEL": "Vincular por Texto ✍️",
     # textbox_output_status
     "TXTBOX_STATUS_LABEL": "Status da Geração da Resposta:",
     "TXTBOX_STATUS_IDLE": "Gerando resposta, aguarde...",

pages/main/tab01_input.py

@@ -0,0 +1,91 @@
+# pages/main/tab01_input.py
+import gradio as gr
+from typing import Dict, Any
+from .strings import STRINGS
+
+def create_input_components() -> Dict[str, Any]:
+    """
+    Cria e retorna os componentes de entrada, onde um seletor de rádio
+    controla a visibilidade de grupos distintos para upload de arquivo e
+    entrada de texto, cada um com seu próprio botão.
+    """
+    
+    input_type_radio = gr.Radio(
+        ["Vinculação por documento 📙", "Vinculação manual ✍️"],
+        label="Selecione o tipo de entrada",
+        value="Vinculação por documento 📙"
+    )
+
+    # --- Grupo de Upload de Arquivo ---
+    # Usando gr.Group para controlar a visibilidade do bloco.
+    # visible=True porque é a opção padrão do Radio.
+    with gr.Group(visible=True) as file_input_group:
+        file_input = gr.File(
+            label="Carregue o documento (PDF, TXT)",
+            file_types=['.pdf', '.txt'],
+        )
+        button_process_file = gr.Button(
+            value=STRINGS["BTN_PROCESS_FILE_LABEL"],
+            interactive=False,
+            variant="primary"
+        )
+
+    # --- Grupo de Entrada de Texto ---
+    # Usando gr.Group com visible=False porque não é a opção padrão.
+    with gr.Group(visible=False) as text_input_group:
+        text_input = gr.Textbox(
+            label="Insira o texto para análise",
+            lines=8,
+            placeholder="relato de dor persistente na articulação do joelho direito...",
+        )
+        button_process_text = gr.Button(
+            value=STRINGS["BTN_PROCESS_TEXT_LABEL"],
+            interactive=False,
+            variant="primary"
+        )
+
+    def _switch_input_visibility(selection: str) -> Dict[gr.Group, Dict[str, bool]]:
+        """Alterna a visibilidade dos grupos de entrada."""
+        is_document_selected = "documento" in selection
+        return {
+            file_input_group: gr.update(visible=is_document_selected),
+            text_input_group: gr.update(visible=not is_document_selected)
+        }
+
+    input_type_radio.change(
+        fn=_switch_input_visibility,
+        inputs=input_type_radio,
+        outputs=[file_input_group, text_input_group]
+    )
+
+    # --- Lógica de habilitação dos botões ---
+    
+    def _update_file_button_state(file_obj: Any) -> gr.Button:
+        """Habilita o botão de arquivo apenas se um arquivo for carregado."""
+        return gr.update(interactive=file_obj is not None)
+
+    def _update_text_button_state(text: str) -> gr.Button:
+        """Habilita o botão de texto apenas se o texto tiver conteúdo."""
+        return gr.update(interactive=bool(text and text.strip()))
+
+    file_input.change(
+        fn=_update_file_button_state,
+        inputs=file_input,
+        outputs=button_process_file
+    )
+    
+    text_input.change(
+        fn=_update_text_button_state,
+        inputs=text_input,
+        outputs=button_process_text
+    )
+
+    # Retornamos os componentes interativos que a view.py precisa manipular.
+    # Os próprios grupos não precisam ser retornados, a menos que se queira manipulá-los.
+    return {
+        "input_type_radio": input_type_radio,
+        "file_input": file_input,
+        "text_input": text_input,
+        "button_process_file": button_process_file,
+        "button_process_text": button_process_text,
+    }

pages/main/tab02_results.py

@@ -0,0 +1,57 @@
+# pages/main/tab02_results.py
+import gradio as gr
+from .strings import STRINGS
+
+def _handle_status_text_change(status_text: str) -> gr.Button:
+    """
+    Listener for the status textbox. Updates the report creation button
+    based on the content of the status textbox.
+    """
+    if status_text == STRINGS["TXTBOX_STATUS_OK"]:
+        return gr.update(value=STRINGS["BTN_CREATE_REPORT_LABEL_ENABLED"], interactive=True, variant="primary")
+    else:
+        return gr.update(value=STRINGS["BTN_CREATE_REPORT_LABEL_DISABLED"], interactive=False, variant="secondary")
+
+def create_tab_results():
+    """
+    Cria e retorna um dicionário com os componentes da UI para a aba de resultados.
+    """
+    gr.Markdown(STRINGS["TAB_1_SUBTITLE"])
+
+    textbox_output_status = gr.Textbox(
+        label=STRINGS["TXTBOX_STATUS_LABEL"],
+        interactive=False,
+        value=""
+    )
+
+    textbox_output_llm_response = gr.Textbox(
+        label=STRINGS["TXTBOX_OUTPUT_LLM_RESPONSE_LABEL"],
+        lines=15,
+        interactive=False,
+        placeholder=STRINGS["TXTBOX_OUTPUT_LLM_RESPONSE_PLACEHOLDER"]
+    )
+
+    button_create_report = gr.Button(
+        STRINGS["BTN_CREATE_REPORT_LABEL_DISABLED"], 
+        interactive=False, 
+        variant="secondary"
+    )
+    
+    button_return_to_input_tab_from_results = gr.Button(
+        STRINGS["BTN_RETURN_LABEL"], 
+        variant="secondary"
+    )
+
+    # Evento para habilitar o botão de criar relatório
+    textbox_output_status.change(
+        fn=_handle_status_text_change,
+        inputs=textbox_output_status,
+        outputs=button_create_report
+    )
+
+    return {
+        "textbox_output_status": textbox_output_status,
+        "textbox_output_llm_response": textbox_output_llm_response,
+        "button_create_report": button_create_report,
+        "button_return_to_input_tab_from_results": button_return_to_input_tab_from_results
+    }

pages/main/tab03_report.py

@@ -0,0 +1,91 @@
+# pages/main/tab03_report.py
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+from typing import Tuple, Optional
+from .strings import STRINGS
+
+# --- Funções de Atualização (Lógica Interna da Aba) ---
+
+def update_dataframe_components(
+    group_data_df: Optional[pd.DataFrame],
+    group_description_df: Optional[pd.DataFrame],
+    individuals_data_df: Optional[pd.DataFrame],
+    individuals_description_df: Optional[pd.DataFrame]
+) -> Tuple[gr.DataFrame, gr.DataFrame, gr.DataFrame, gr.DataFrame]:
+    """Atualiza os componentes visíveis de DataFrame do Gradio com novos dados."""
+    return (
+        gr.DataFrame(value=group_data_df),
+        gr.DataFrame(value=group_description_df),
+        gr.DataFrame(value=individuals_data_df),
+        gr.DataFrame(value=individuals_description_df)
+    )
+
+def update_plot_components(
+    pie_chart_figure: Optional[go.Figure],
+    bar_chart_figure: Optional[go.Figure],
+    tree_map_figure: Optional[go.Figure]
+) -> Tuple[gr.Plot, gr.Plot, gr.Plot]:
+    """Atualiza os componentes visíveis de Gráfico do Gradio com novas figuras."""
+    return (
+        gr.Plot(value=pie_chart_figure),
+        gr.Plot(value=bar_chart_figure),
+        gr.Plot(value=tree_map_figure)
+    )
+
+def update_download_button_component(report_file_path: Optional[str]) -> gr.DownloadButton:
+    """Atualiza o componente de DownloadButton do Gradio com o caminho do PDF."""
+    if report_file_path:
+        return gr.update(value=report_file_path, label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_ENABLED"], interactive=True, variant="primary")
+    else:
+        return gr.update(label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_ERROR"], interactive=False, variant="secondary")
+
+def create_tab_report() -> dict:
+    """
+    Cria a aba de relatório e retorna um dicionário contendo
+    os componentes da UI e as funções para atualizá-los.
+    """
+    gr.Markdown(STRINGS["TAB_2_SUBTITLE"])
+
+    with gr.Row():
+        dataframe_display_grouped_data = gr.DataFrame(label=STRINGS["DF_GROUP_DATA"])
+        dataframe_display_grouped_description = gr.DataFrame(label=STRINGS["DF_GROUP_DESC"])
+    # ... (outros componentes são criados aqui como antes) ...
+    with gr.Row():
+        dataframe_display_individual_data = gr.DataFrame(label=STRINGS["DF_INDIVIDUAL_DATA"])
+        dataframe_display_individual_description = gr.DataFrame(label=STRINGS["DF_INDIVIDUAL_DESC"])
+
+    plot_display_pie_chart = gr.Plot(label=STRINGS["PLOT_PIE_LABEL"])
+    plot_display_bar_chart = gr.Plot(label=STRINGS["PLOT_BAR_LABEL"])
+    plot_display_tree_map = gr.Plot(label=STRINGS["PLOT_TREE_LABEL"])
+
+    download_button_report_pdf = gr.DownloadButton(
+        label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_DISABLED"],
+        interactive=False,
+        variant="secondary"
+    )
+
+    button_return_to_input_tab_from_report = gr.Button(
+        STRINGS["BTN_RETURN_LABEL"],
+        variant="secondary"
+    )
+
+    # MODIFICAÇÃO: Retornamos um dicionário estruturado
+    return {
+        "components": {
+            "dataframe_display_grouped_data": dataframe_display_grouped_data,
+            "dataframe_display_grouped_description": dataframe_display_grouped_description,
+            "dataframe_display_individual_data": dataframe_display_individual_data,
+            "dataframe_display_individual_description": dataframe_display_individual_description,
+            "plot_display_pie_chart": plot_display_pie_chart,
+            "plot_display_bar_chart": plot_display_bar_chart,
+            "plot_display_tree_map": plot_display_tree_map,
+            "download_button_report_pdf": download_button_report_pdf,
+            "button_return_to_input_tab_from_report": button_return_to_input_tab_from_report
+        },
+        "update_fns": {
+            "dataframes": update_dataframe_components,
+            "plots": update_plot_components,
+            "download": update_download_button_component
+        }
+    }

pages/main/view.py

@@ -1,265 +1,144 @@
+# pages/main/view.py
 import os
-import pandas as pd # Importado para type hinting em _update_dataframes_from_states
-import plotly.graph_objects as go # Importado para type hinting em _update_plots_from_states
 import gradio as gr
-from typing import Any, Generator, Tuple, Optional
-from functools import partial
+from typing import Tuple, Any
 
-from utils.rag_retriever import initialize_rag_system
-from utils.report_creation import process_report_data, create_report_plots, generate_report_pdf
+from utils.report.report_creation import generate_report_pdf
+from utils.report.graph_creation import create_report_plots
+from utils.report.dataframe_creation import process_report_data
 
-#from .scripts import extract_phrases_from_gradio_file, process_phrases_with_rag_llm
-from .scripts import process_phrases_with_api_llm
+from .scripts import process_inputs_to_api
 from .strings import STRINGS
+from .tab01_input import create_input_components
+from .tab02_results import create_tab_results
+from .tab03_report import create_tab_report
 
-# --- Configurações Iniciais do RAG ---
-#rag_docs, rag_index, rag_embedder = [None, None, None] # TODO: Apenas para Teste
-# rag_docs, rag_index, rag_embedder = initialize_rag_system() # DEPRECATED
 img1 = os.path.join(os.getcwd(), "static", "images", "logo.jpg")
 
-# --- Função Auxiliadora para Processamento de Frases ---
-process_fn_with_rag_args = partial(process_phrases_with_api_llm)
-
-# --- Funções Auxiliares (Listeners e Controladores de UI) ---
-def _handle_input_text_change(text_input: str) -> gr.Button:
-    """
-    Listener for the input textbox. Updates the generation button
-    based on the content of the textbox.
-    """
-    if len(text_input.strip()) > 2:
-        return gr.update(value=STRINGS["BTN_PROCESS_INPUT_LABEL_ENABLED"], interactive=True, variant="primary")
-    else:
-        return gr.update(value=STRINGS["BTN_PROCESS_INPUT_LABEL_DISABLED"], interactive=False, variant="secondary")
-
-def _handle_status_text_change(status_text: str) -> gr.Button:
-    """
-    Listener for the status textbox. Updates the report creation button
-    based on the content of the status textbox.
-    """
-    if status_text == STRINGS["TXTBOX_STATUS_OK"]:
-        return gr.update(value=STRINGS["BTN_CREATE_REPORT_LABEL_ENABLED"], interactive=True, variant="primary")
-    else:
-        return gr.update(value=STRINGS["BTN_CREATE_REPORT_LABEL_DISABLED"], interactive=False, variant="secondary")
-
 def _switch_to_report_tab_and_enable_interaction() -> Tuple[gr.Tabs, gr.TabItem]:
-    """
-    Switches to the report tab and enables interaction for it.
-    Returns updated Tabs and TabItem components.
-    """
+    """Muda para a aba de relatório e a torna interativa."""
     return gr.update(selected=2), gr.update(label=STRINGS["TAB_2_TITLE"] + " ✅", interactive=True)
 
-# --- Atualizar Componentes Visíveis a partir de States ---
-def _update_dataframe_components(group_data_df: Optional[pd.DataFrame],
-                                 group_description_df: Optional[pd.DataFrame],
-                                 individuals_data_df: Optional[pd.DataFrame],
-                                 individuals_description_df: Optional[pd.DataFrame]
-                                 ) -> Tuple[gr.DataFrame, gr.DataFrame, gr.DataFrame, gr.DataFrame]:
-    """
-    Updates the visible Gradio DataFrame components with new data.
-    """
-    return (
-        gr.DataFrame(value=group_data_df),
-        gr.DataFrame(value=group_description_df),
-        gr.DataFrame(value=individuals_data_df),
-        gr.DataFrame(value=individuals_description_df)
-    )
-
-def _update_plot_components(pie_chart_figure: Optional[go.Figure],
-                            bar_chart_figure: Optional[go.Figure],
-                            tree_map_figure: Optional[go.Figure]
-                            ) -> Tuple[gr.Plot, gr.Plot, gr.Plot]:
-    """
-    Updates the visible Gradio Plot components with new figures.
-    """
-    print("Atualizando gráficos visíveis...")
-    return (
-        gr.Plot(value=pie_chart_figure),
-        gr.Plot(value=bar_chart_figure),
-        gr.Plot(value=tree_map_figure)
-    )
-
-def _update_download_button_component(report_file_path: Optional[str]) -> gr.DownloadButton:
-    """
-    Updates the Gradio DownloadButton component with the PDF path.
-    """
-    if report_file_path:
-        return gr.update(value=report_file_path, label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_ENABLED"], interactive=True, variant="primary")
-    else:
-        return gr.update(label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_ERROR"], interactive=False, variant="secondary")
-
-
-# --- Construção da Interface Gradio ---
 with gr.Blocks(title=STRINGS["APP_TITLE"]) as interface:
-    # --- States para Armazenar Dados Brutos (entre as etapas do .then()) ---
-    state_dataframe_group = gr.State(None)
-    state_dataframe_group_description = gr.State(None)
-    state_dataframe_individuals = gr.State(None)
-    state_dataframe_individuals_description = gr.State(None)
-    state_figure_pie_chart = gr.State(None)
-    state_figure_bar_chart = gr.State(None)
-    state_figure_tree_map = gr.State(None)
-    state_report_file_path = gr.State(None)
-    state_llm_response = gr.State(None)
-
+    # --- States ---
+    states = {
+        "dataframe_group": gr.State(None),
+        "dataframe_group_description": gr.State(None),
+        "dataframe_individuals": gr.State(None),
+        "dataframe_individuals_description": gr.State(None),
+        "figure_pie_chart": gr.State(None),
+        "figure_bar_chart": gr.State(None),
+        "figure_tree_map": gr.State(None),
+        "report_file_path": gr.State(None),
+        "llm_response": gr.State(None)
+    }
+
+    # --- Header ---
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown(
-                f"# {STRINGS['APP_TITLE']}",
-                elem_id="md_app_title",
-            )
-            gr.Markdown(
-                f"{STRINGS['APP_DESCRIPTION']}",
-                elem_id="md_app_description",
-            )
-    
-        gr.Image(
-        value=img1,
-        height=64,
-        elem_id="logo_img",
-        placeholder="CIF Link Logo",
-        container=False,
-        show_label=False,
-        show_download_button=False,
-        scale=0
-        )
+            gr.Markdown(f"# {STRINGS['APP_TITLE']}")
+            gr.Markdown(f"{STRINGS['APP_DESCRIPTION']}")
+        gr.Image(value=img1, height=64, container=False, show_label=False, scale=0)
 
+    # --- Estrutura das Abas ---
+    components = {}
     with gr.Tabs() as tabs_main_navigation:
-        with gr.TabItem(STRINGS["TAB_0_TITLE"], id=0):
-            gr.Markdown(STRINGS["TAB_0_SUBTITLE"])
-# DEPRECATED: gr.File volta em uma futura versão 
-#            file_input_user_document = gr.File(
-#                label=STRINGS["FILE_INPUT_LABEL"],
-#                type="filepath",
-#                file_types=['.txt', '.pdf', '.docx'],
-#                interactive=False
-#            )
-
-            textbox_input_phrases = gr.Textbox(
-                label=STRINGS["TXTBOX_INPUT_PHRASES_LABEL"],
-                placeholder=STRINGS["TXTBOX_INPUT_PHRASES_PLACEHOLDER"],
-                lines=10,
-                interactive=True
-            )
-
-            button_process_input = gr.Button(STRINGS["BTN_PROCESS_INPUT_LABEL_DISABLED"], interactive=False, variant="secondary")
-
-#            file_input_user_document.upload(
-#                fn=extract_phrases_from_gradio_file,
-#                inputs=file_input_user_document,
-#                outputs=textbox_input_phrases
-#            )
-
-            textbox_input_phrases.change(
-                fn=_handle_input_text_change,
-                inputs=textbox_input_phrases,
-                outputs=button_process_input
-            )
-
-        with gr.TabItem(STRINGS["TAB_1_TITLE"] + " 🔒", interactive=False, id=1) as tab_item_processing_results:
-            gr.Markdown(STRINGS["TAB_1_SUBTITLE"])
-
-            textbox_output_status = gr.Textbox(
-                label=STRINGS["TXTBOX_STATUS_LABEL"],
-                interactive=False,
-                value=""
-            )
-
-            textbox_output_llm_response = gr.Textbox(
-                label=STRINGS["TXTBOX_OUTPUT_LLM_RESPONSE_LABEL"],
-                lines=15,
-                interactive=False,
-                placeholder=STRINGS["TXTBOX_OUTPUT_LLM_RESPONSE_PLACEHOLDER"]
-            )
-
-            button_create_report = gr.Button(STRINGS["BTN_CREATE_REPORT_LABEL_DISABLED"], interactive=False, variant="secondary")
-            button_return_to_input_tab_from_results = gr.Button(STRINGS["BTN_RETURN_LABEL"], variant="secondary")
-
-            textbox_output_status.change(
-                fn=_handle_status_text_change,
-                inputs=textbox_output_status,
-                outputs=button_create_report
-            )
-
-            # Captura a resposta da LLM no estado para uso posterior em outras funções
-            textbox_output_llm_response.change(
-                fn=lambda response_text: response_text, # Função identidade para passar o valor
-                inputs=textbox_output_llm_response,
-                outputs=state_llm_response
-            )
-
-        with gr.TabItem(STRINGS["TAB_2_TITLE"] + " 🔒", interactive=False, id=2) as tab_item_report_visualization:
-            gr.Markdown(STRINGS["TAB_2_SUBTITLE"])
-
-            with gr.Row():
-                dataframe_display_grouped_data = gr.DataFrame(label=STRINGS["DF_GROUP_DATA"])
-                dataframe_display_grouped_description = gr.DataFrame(label=STRINGS["DF_GROUP_DESC"])
-
-            with gr.Row():
-                dataframe_display_individual_data = gr.DataFrame(label=STRINGS["DF_INDIVIDUAL_DATA"])
-                dataframe_display_individual_description = gr.DataFrame(label=STRINGS["DF_INDIVIDUAL_DESC"])
-
-            plot_display_pie_chart = gr.Plot(label=STRINGS["PLOT_PIE_LABEL"])
-            plot_display_bar_chart = gr.Plot(label=STRINGS["PLOT_BAR_LABEL"])
-            plot_display_tree_map = gr.Plot(label=STRINGS["PLOT_TREE_LABEL"])
+        with gr.TabItem(STRINGS["TAB_0_TITLE"], id=0) as tab_input:
+            # Cria os componentes de entrada da Tab 1
+            components.update(create_input_components())
+
+        with gr.TabItem(STRINGS["TAB_1_TITLE"] + " 🔒", interactive=False, id=1) as tab_results:
+            components.update(create_tab_results())
+            components["tab_item_processing_results"] = tab_results
+
+        with gr.TabItem(STRINGS["TAB_2_TITLE"] + " 🔒", interactive=False, id=2) as tab_report:
+            report_elements = create_tab_report()
+            components.update(report_elements["components"])
+            components["tab_item_report_visualization"] = tab_report
+
+    # --- Ações dos Botões de Processamento ---
+
+    # Saídas comuns para ambos os botões de processamento
+    common_api_outputs = [
+        components["textbox_output_status"],
+        components["textbox_output_llm_response"],
+        tabs_main_navigation,
+        components["tab_item_processing_results"]
+    ]
+
+    # Botão para processar ARQUIVO
+    components["button_process_file"].click(
+        fn=process_inputs_to_api,
+        # Inputs: (None para texto, objeto de arquivo)
+        inputs=[gr.State(None), components["file_input"]],
+        outputs=common_api_outputs
+    )
 
-            download_button_report_pdf = gr.DownloadButton(label=STRINGS["DOWNLOAD_BTN_REPORT_LABEL_DISABLED"], interactive=False, variant="secondary")
-            button_return_to_input_tab_from_report = gr.Button(STRINGS["BTN_RETURN_LABEL"], variant="secondary") # Botão para voltar à aba 0 da aba 2
+    # Botão para processar TEXTO
+    components["button_process_text"].click(
+        fn=process_inputs_to_api,
+        # Inputs: (string de texto, None para arquivo)
+        inputs=[components["text_input"], gr.State(None)],
+        outputs=common_api_outputs
+    )
 
-    # --- FLUXO DE EVENTOS MULTI-CHAINING PARA O RELATÓRIO ---
-    button_process_input.click(
-        fn=process_fn_with_rag_args,
-        inputs=[textbox_input_phrases],
-        outputs=[textbox_output_status, textbox_output_llm_response, tabs_main_navigation, tab_item_processing_results]
+    components["textbox_output_llm_response"].change(
+        fn=lambda response_text: response_text,
+        inputs=components["textbox_output_llm_response"],
+        outputs=states["llm_response"]
     )
 
-    button_create_report.click(
-        fn=_switch_to_report_tab_and_enable_interaction, # 1. Muda de aba e a habilita - Switches tab and enables it
-        inputs=[],
-        outputs=[tabs_main_navigation, tab_item_report_visualization]
+    # --- Fluxo de Geração de Relatório ---
+    components["button_create_report"].click(
+        fn=_switch_to_report_tab_and_enable_interaction,
+        outputs=[tabs_main_navigation, components["tab_item_report_visualization"]]
     ).then(
-        fn=process_report_data, # 2. Processa a resposta da LLM e salva os DataFrames brutos nos states
-        inputs=[state_llm_response],
+        fn=process_report_data,
+        inputs=[states["llm_response"]],
+        outputs=list(states.values())[:4]
+    ).then(
+        fn=report_elements["update_fns"]["dataframes"],
+        inputs=list(states.values())[:4],
         outputs=[
-            state_dataframe_group, state_dataframe_group_description,
-            state_dataframe_individuals, state_dataframe_individuals_description
+            components["dataframe_display_grouped_data"],
+            components["dataframe_display_grouped_description"],
+            components["dataframe_display_individual_data"],
+            components["dataframe_display_individual_description"],
         ]
     ).then(
-        fn=_update_dataframe_components, # 3. Atualiza os componentes Gradio DataFrame visíveis
-        inputs=[state_dataframe_group, state_dataframe_group_description, state_dataframe_individuals, state_dataframe_individuals_description],
-        outputs=[dataframe_display_grouped_data, dataframe_display_grouped_description, dataframe_display_individual_data, dataframe_display_individual_description]
-    ).then(
-        fn=create_report_plots, # 4. Pega DataFrames dos states e gera os gráficos Plotly brutos nos states
-        inputs=[state_dataframe_group, state_dataframe_individuals],
-        outputs=[state_figure_pie_chart, state_figure_bar_chart, state_figure_tree_map]
+        fn=create_report_plots,
+        inputs=[states["dataframe_group"], states["dataframe_individuals"]],
+        outputs=[states["figure_pie_chart"], states["figure_bar_chart"], states["figure_tree_map"]]
     ).then(
-        fn=_update_plot_components, # 5. Atualiza os componentes Gradio Plot visíveis
-        inputs=[state_figure_pie_chart, state_figure_bar_chart, state_figure_tree_map],
-        outputs=[plot_display_pie_chart, plot_display_bar_chart, plot_display_tree_map]
+        fn=report_elements["update_fns"]["plots"],
+        inputs=[states["figure_pie_chart"], states["figure_bar_chart"], states["figure_tree_map"]],
+        outputs=[
+            components["plot_display_pie_chart"],
+            components["plot_display_bar_chart"],
+            components["plot_display_tree_map"]
+        ]
     ).then(
-        fn=generate_report_pdf, # 6. Gera o PDF a partir de todos os dados e gráficos (states)
+        fn=generate_report_pdf,
         inputs=[
-            state_llm_response, # Resposta LLM original - Original LLM response
-            state_dataframe_group, state_dataframe_group_description, state_dataframe_individuals, state_dataframe_individuals_description,
-            state_figure_pie_chart, state_figure_bar_chart, state_figure_tree_map
+           states["llm_response"],
+           states["dataframe_group"],
+           states["dataframe_group_description"],
+           states["dataframe_individuals"],
+           states["dataframe_individuals_description"],
+           states["figure_pie_chart"],
+           states["figure_bar_chart"],
+           states["figure_tree_map"]
         ],
-        outputs=[state_report_file_path] # Atualiza o state do caminho do PDF
+        outputs=[states["report_file_path"]]
     ).then(
-        fn=_update_download_button_component, # 7. Atualiza o botão de download
-        inputs=[state_report_file_path],
-        outputs=[download_button_report_pdf]
+        fn=report_elements["update_fns"]["download"],
+        inputs=[states["report_file_path"]],
+        outputs=[components["download_button_report_pdf"]]
     )
 
-    # --- Eventos para voltar para a aba de entrada ---
-    button_return_to_input_tab_from_results.click(
-        fn=lambda: gr.Tabs(selected=0),
-        inputs=[],
-        outputs=tabs_main_navigation
-    )
-    button_return_to_input_tab_from_report.click(
-        fn=lambda: gr.Tabs(selected=0),
-        inputs=[],
-        outputs=tabs_main_navigation
-    )
+    # --- Botões de Navegação "Voltar" ---
+    components["button_return_to_input_tab_from_results"].click(fn=lambda: gr.update(selected=0), outputs=tabs_main_navigation)
+    components["button_return_to_input_tab_from_report"].click(fn=lambda: gr.update(selected=0), outputs=tabs_main_navigation)
 
 if __name__ == "__main__":
     print("Executando a aplicação Gradio...")

pages/theme.py

@@ -1,7 +1,6 @@
+# pages/theme.py
 import gradio as gr
 
-font=gr.themes.GoogleFont('Montserrat'),
-
 softCIF = gr.themes.Soft(
     primary_hue=gr.themes.Color(c100="#F7CDC9", c200="#F1A9A2", c300="#EB867B", c400="#E56556", c50="#FCEEED", c500="#D4291A", c600="#C02417", c700="#A91F14", c800="#991b1b", c900="#921A11", c950="#7B150E"),
     secondary_hue="teal",

sandbox/README.md

@@ -1,3 +1,5 @@
 # /Sandbox
 
-Diretório específico para scripts de testes e/ou versõess alternativas.
+Diretório específico para scripts de testes e/ou versõess alternativas, além de arquivos de texto para referência ou rápida utilização em testes.
+
+Verifique se .env e credentials/ estão corretamente configurados.

sandbox/questionariosf-36.txt

@@ -1,95 +0,0 @@
-1- Em geral você diria que sua saúde é:
-2- Comparada há um ano atrás, como você se classificaria sua idade em geral, agora?
-3- Os seguintes itens são sobre atividades que você poderia fazer atualmente durante um dia comum.
-a) Atividades Rigorosas, que exigem muito esforço, tais como correr, levantar objetos pesados, participar em
-esportes árduos.
-b) Atividades moderadas, tais como mover uma mesa, passar aspirador de pó, jogar bola, varrer a casa.
-c) Levantar ou carregar mantimentos
-d) Subir vários lances de escada
-e) Subir um lance de escada
-f) Curvar-se, ajoelhar-se ou dobrar- se
-g) Andar mais de 1 quilômetro
-h) Andar vários quarteirões
-i) Andar um quarteirão
-j) Tomar banho ou vestir-se
-4- Durante as últimas 4 semanas, você teve algum dos seguintes problemas com seu trabalho ou com alguma atividade regular, como conseqüência de sua saúde física?
-a) Você diminui a quantidade de tempo que se dedicava ao seu  trabalho ou a outras atividades?
-b) Realizou menos tarefas do que você gostaria?
-c) Esteve limitado no seu tipo de trabalho ou a outras atividades.
-d) Teve dificuldade de fazer seu trabalho ou outras atividades
-5- Durante as últimas 4 semanas, você teve algum dos seguintes problemas com seu trabalho
-ou outra atividade regular diária, como conseqüência de algum problema emocional (como
-se sentir deprimido ou ansioso)?
-a) Você diminui a quantidade de tempo que se dedicava ao seu trabalho ou a outras atividades?
-b) Realizou menos tarefas do que você gostaria?
-c) Não realizou ou fez qualquer das atividades com tanto cuidado como geralmente faz.
-6- Durante as últimas 4 semanas, de que maneira sua saúde física ou problemas emocionais interferiram nas suas atividades sociais normais, em relação à família, amigos ou em grupo?
-7- Quanta dor no corpo você teve durante as últimas 4 semanas?
-8- Durante as últimas 4 semanas, quanto a dor interferiu com seu trabalho normal (incluindo o trabalho dentro de casa)?
-9- Estas questões são sobre como você se sente e como tudo tem acontecido com você
-durante as últimas 4 semanas.
-Para cada questão, por favor dê uma resposta que mais se
-aproxime de maneira como você se sente, em relação às últimas 4 semanas.
-Uma
-A maior       Uma boa     Alguma
-Todo                                          pequena
-parte do      parte do    parte do            Nunca
-Tempo                                          parte do
-tempo         tempo       tempo
-tempo
-a) Quanto tempo você
-tem se sentindo cheio de
-1           2           3              4      5        6
-vigor, de vontade, de
-força?
-b) Quanto tempo você
-tem se sentido uma            1           2           3              4      5        6
-pessoa muito nervosa?
-c) Quanto tempo você
-tem se sentido tão
-1           2           3              4      5        6
-deprimido que nada
-pode anima-lo?
-d) Quanto tempo você
-tem se sentido calmo ou       1           2           3              4      5        6
-tranqüilo?
-e) Quanto tempo você
-tem se sentido com            1           2           3              4      5        6
-muita energia?
-f) Quanto tempo você
-tem       se     sentido      1           2           3              4      5        6
-desanimado ou abatido?
-g) Quanto tempo você
-tem       se     sentido      1           2           3              4      5        6
-esgotado?
-h) Quanto tempo você
-tem se sentido uma            1           2           3              4      5        6
-pessoa feliz?
-i) Quanto tempo você
-1           2           3              4      5        6
-tem se sentido cansado?
-10- Durante as últimas 4 semanas, quanto de seu tempo a sua saúde física ou problemas
-emocionais interferiram com as suas atividades sociais (como visitar amigos, parentes, etc)?
-Todo      A maior parte do        Alguma parte do    Uma pequena         Nenhuma parte
-Tempo          tempo                   tempo          parte do tempo        do tempo
-1               2                      3                   4                  5
-11- O quanto verdadeiro ou falso é cada uma das afirmações para você?
-A maioria             A maioria
-Definitivamente                  Não                   Definitiva-
-das vezes             das vezes
-verdadeiro                      sei                  mente falso
-verdadeiro              falso
-a) Eu costumo obedecer
-um      pouco      mais
-1              2           3         4              5
-facilmente que as outras
-pessoas
-b) Eu sou tão saudável
-quanto qualquer pessoa           1              2           3         4              5
-que eu conheço
-c) Eu acho que a minha
-1              2           3         4              5
-saúde vai piorar
-d) Minha saúde é
-1              2           3         4              5
-excelente

utils/api_gemini.py

@@ -1,53 +0,0 @@
-import os
-
-from dotenv import load_dotenv
-from google import genai
-from google.genai import types
-
-from utils.prompts import icf_gemini_prompt
-
-# Carrega as variáveis de ambiente (se você usar .env)
-load_dotenv()
-GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
-MODEL_ID = os.getenv('MODEL_ID')
-CONTEXT_FIXED = ""
-context_path = os.path.join(os.getcwd(), "RAG", "CIF_Lista.txt")
-
-try:
-    with open(context_path, 'r', encoding='utf-8') as f:
-        CONTEXT_FIXED = f.read()
-except FileNotFoundError:
-    CONTEXT_FIXED = "Erro: Arquivo de contexto não encontrado."
-
-print("Context: ", CONTEXT_FIXED[:100])
-
-def api_generate(user_input: str) -> str:
-    client = genai.Client(api_key=GEMINI_API_KEY)
-
-    llm_config = types.GenerateContentConfig(
-        response_mime_type='text/plain',
-        seed=1,
-        system_instruction=icf_gemini_prompt,
-    )
-
-    user_prompt_content = types.Content(
-        role='user',
-        parts=[
-            types.Part.from_text(text=CONTEXT_FIXED),
-            types.Part.from_text(text=user_input)
-        ],
-    )
-
-    response = client.models.generate_content(
-        model=MODEL_ID,
-        contents=user_prompt_content,
-        config=llm_config
-    )
-
-    return response.text
-
-if __name__ == "__main__":
-    test_string = "O paciente sente dores abdominais agudas, localizadas principalmente na região inferior do abdômen. Fadiga. Náuseas. Vômitos.  Diarreia. Dificuldade para respirar. Dor no peito. O paciente observa vermelhidão persistente na pele, acompanhada de coceira em áreas específicas. Eu não consigo enxergar objetos a longas distâncias, com visão embaçada ao tentar focar. Tontura ou perda de equilíbrio. O paciente apresenta fraqueza súbita em um lado do corpo, dificultando movimentos do braço e perna."
-    print(f"Enviando...\n{test_string}")
-    res = api_generate(test_string)
-    print(res)

utils/apis/README.md

@@ -0,0 +1,3 @@
+# Utils/apis
+
+Aqui se armazena os códigos relacionados a chamada de APIs: `genai` e `gspread`.

utils/apis/gemini.py

@@ -0,0 +1,160 @@
+# utils/apis/gemini.py
+import os
+import pathlib
+
+from typing import Optional, Union, List
+from dotenv import load_dotenv
+from google import genai
+from google.genai import types
+
+from utils.prompts import icf_gemini_prompt
+
+load_dotenv()
+
+# Chave da API e ID do Modelo obtidos do ambiente
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+if not GEMINI_API_KEY:
+    raise ValueError("A variável de ambiente 'GEMINI_API_KEY' não foi definida.")
+
+MODEL_ID = os.getenv('MODEL_ID', 'gemini-2.5-flash')
+# --- CAMINHOS E ARQUIVOS DE CONTEXTO ---
+
+# Define o caminho para o prompt do sistema e o PDF de contexto usando pathlib para compatibilidade de SO
+BASE_DIR = pathlib.Path(__file__).parent.parent.parent
+PDF_CONTEXT_PATH = BASE_DIR / "CIF" / "ListaCIF.pdf"
+SYSTEM_PROMPT_PATH = BASE_DIR / "utils" / "prompts.py"
+
+def _load_sys_instruction(caminho: pathlib.Path) -> str:
+    """Carrega a string do prompt do sistema a partir de um arquivo Python."""
+    try:        
+        return icf_gemini_prompt
+    except (ImportError, FileNotFoundError):
+        print(f"Aviso: Não foi possível encontrar ou importar o prompt do sistema de '{caminho}'. Usando um prompt padrão.")
+        return "Você é um especialista na Classificação Internacional de Funcionalidade (CIF). Classifique o texto fornecido de acordo com a CIF e forneça uma análise detalhada."
+
+def _create_file_part(file_path_str: str) -> types.Part:
+    """
+    Valida, lê e cria um objeto Part a partir de um caminho de arquivo.
+
+    Esta função verifica se o arquivo existe e se sua extensão (.txt ou .pdf) é
+    suportada. Em caso afirmativo, lê os bytes do arquivo e retorna um objeto
+    `types.Part` com o MIME type correto.
+
+    Args:
+        file_path_str: O caminho para o arquivo, recebido como string.
+
+    Returns:
+        Um objeto `types.Part` pronto para ser enviado à API Gemini.
+
+    Raises:
+        FileNotFoundError: Se o arquivo não for encontrado no caminho especificado.
+        ValueError: Se a extensão do arquivo não for suportada.
+    """
+    input_file_path = pathlib.Path(file_path_str)
+
+    if not input_file_path.is_file():
+        raise FileNotFoundError(f"O arquivo de entrada do usuário não foi encontrado: {input_file_path}")
+
+    file_extension = input_file_path.suffix.lower()
+    
+    if file_extension == '.pdf':
+        mime_type = 'application/pdf'
+    elif file_extension == '.txt':
+        mime_type = 'text/plain'
+    else:
+        raise ValueError(
+            f"Tipo de arquivo '{file_extension}' não suportado. "
+            "Por favor, envie um arquivo .txt ou .pdf."
+        )
+    
+    return types.Part.from_bytes(
+        data=input_file_path.read_bytes(),
+        mime_type=mime_type
+    )
+
+def api_generate(
+    input_text: Optional[str] = None,
+    input_file: Optional[Union[str, pathlib.Path]] = None,
+) -> str:
+    """
+    Gera uma análise baseada na CIF a partir de um texto ou arquivo de entrada.
+
+    Utiliza um PDF da CIF como contexto fixo e combina com a entrada do usuário
+    (seja um texto direto ou o conteúdo de um arquivo) para gerar uma resposta
+    usando a API do Gemini.
+
+    Args:
+        input_text: Uma string contendo o texto a ser analisado.
+        input_file: O caminho para um arquivo de texto (.txt) cujo conteúdo
+                    será analisado.
+
+    Returns:
+        A string com a análise gerada pelo modelo.
+
+    Raises:
+        ValueError: Se ambos `input_text` e `input_file` forem fornecidos, ou se
+                    nenhum dos dois for fornecido.
+        FileNotFoundError: Se o arquivo `input_file` ou o PDF de contexto
+                           não forem encontrados.
+    """
+    
+    # 1. Validação da entrada (garante que ou texto ou arquivo foi fornecido, mas não ambos)
+    if not (input_text is None) ^ (input_file is None):
+        raise ValueError("Forneça exatamente um dos parâmetros: 'input_text' ou 'input_file'.")
+
+    # 2. Preparação do Conteúdo (Contents)
+    if not PDF_CONTEXT_PATH.is_file():
+        raise FileNotFoundError(f"Arquivo de contexto PDF não encontrado em: {PDF_CONTEXT_PATH}")
+
+
+    client = genai.Client(api_key=GEMINI_API_KEY)
+
+    system_instruction = _load_sys_instruction(SYSTEM_PROMPT_PATH)
+
+    llm_config = types.GenerateContentConfig(
+        thinking_config = types.ThinkingConfig(
+            thinking_budget=-1,
+            ),
+        response_mime_type='text/plain',
+        seed=1,
+        system_instruction=[
+            types.Part.from_text(text=system_instruction),
+        ],
+    )
+
+    user_contents = [
+        types.Part.from_bytes(
+            data=PDF_CONTEXT_PATH.read_bytes(),
+            mime_type='application/pdf'
+        )
+    ]
+
+    # Se a entrada for texto, adiciona um 'Part' de texto.
+    if input_text:        
+        user_contents.append(
+            types.Part.from_text(
+                text=input_text,
+            )
+        )
+    
+    # Adiciona o arquivo do usuário como um 'Part' de PDF, enviando seus bytes.
+    if input_file:
+        file_part = _create_file_part(input_file)
+        user_contents.append(file_part)
+        '''
+        input_file_path = pathlib.Path(input_file)
+        user_contents.append(
+            types.Part.from_bytes(
+                data=input_file_path.read_bytes(),
+                mime_type='application/pdf'
+            )
+        )
+        '''
+    
+    response = client.models.generate_content(
+        model=MODEL_ID,
+        contents=user_contents,
+        config=llm_config
+    )
+    
+    return response.text

utils/phrase_extractor.py

@@ -1,3 +1,4 @@
+# DEPRECATED: Este script foi uma tentativa de extrair frases localmente.
 import fitz  # PyMuPDF: Library for working with PDF files
 from docx import Document  # python-docx: Library for working with DOCX files
 import os  # Module for interacting with the operating system (file paths)

utils/prompts.py

@@ -17,27 +17,49 @@ def icf_classifier_prompt(context, input_text):
         - **Justificativa**: [Explicação baseada no Contexto]
     """
 
-icf_gemini_prompt="""
-Você é um assistente especializado na Classificação Internacional de Funcionalidade, Incapacidade e Saúde (CIF). Sua tarefa é analisar frases de entrada e classificá-la de acordo com os componentes da CIF, usando o arquivo de *Contexto CIF* e aplicando seu conhecimento sobre a CIF para identificar conceitos que podem não estar explicitamente no *Contexto CIF*, mas que são relevantes.
-
-**Instruções para a Classificação:**
-1.  *Conceito Significativo:* Extraia o propósito, a ideia central, de cada frase preesente no texto de entrada, independentemente de sua forma (pergunta ou afirmação). Extraia frases por ";", "." e "\n" (quebras de linha). Em caso de vírgulas, avalie se as frases se complementam ou se possuem conceito significativo distintos.
-2.  *Verifique a Vinculação com a CIF (priorizando o *contexto CIF*, mas não se limitando a ele):*
-- *Priorize o Contexto CIF:* Primeiramente, examine o *Contexto CIF* fornecido. Se houver termos, códigos ou descrições que se relacionam diretamente com o "Conceito Significativo" da frase, utilize-os.
- - *Aplique Conhecimento Adicional da CIF:* Se o *Conceito Significativo* não for explicitamente coberto ou detalhado o suficiente no *Contexto CIF*, use seu conhecimento abrangente da CIF para identificar a correspondência mais próxima. Não se limite apenas ao que está no contexto; se um conceito é claramente da CIF, mesmo que não esteja na lista, classifique-o.
- - *Não Coberto:* Se, após a análise do *contexto CIF* e do seu conhecimento geral da CIF, o termo ou conceito não puder ser razoavelmente vinculado a nenhum domínio da CIF, classifique-o como "Não coberto."
-3.  **Determine o Componente da CIF:** Para os conceitos vinculados à CIF, identifique a qual dos quatro componentes principais ele pertence, baseado na natureza do conceito e no código (se disponível):
-- *Funções Corporais (b)*; *Estruturas Corporais (s)*; *Atividades e Participação (d)*; *Fatores Ambientais (e)*;
-4.  *Não Definido:* Se um termo ou conceito for claramente mencionado na CIF (seja no contexto ou no seu conhecimento geral), mas não puder ser categorizado em nenhum dos quatro componentes principais da CIF, classifique-o como "Não definido." Isso é possível para termos mais genéricos ou que exigem mais contexto para uma vinculação específica.
-
-**Formato da Saída:**
-Para cada *Conceito Significativo* identificado na `Frase de Entrada do Usuário`, retorne um bloco de texto, respeitando o idioma de entrada, com a seguinte estrutura:
-
-- Frase de Entrada: [A frase original]
-  - Conceito Significativo: [O conceito significativo extraído da frase]
-  - Status de Cobertura pela CIF: ["Coberto", "Não Coberto (N.C.)", ou "Não Definido (N.D.)"]
-  - Categoria CIF: [Se "Coberto", indique: "Funções Corporais", "Estruturas Corporais", "Atividades e Participação", "Fatores Ambientais". Caso contrário, retorne "N.C." ou "N.D."]
-  - Codificação CIF: [Código + Título] [Se "Coberto", o código e título mais relevante da CIF. Caso contrário, retorne "N.C." ou "N.D."]
-  - Descrição CIF: [Se "Coberto", a descrição completa ou parte dela que se relaciona mais diretamente com o conceito. Se "Não Coberto": o conceito não está representado nem como código nem como referência na CIF, Se "Não Definido": conceito está referenciado pela CIF, mas não tem um código específico nem pertence a um componente]
-  - Justificativa da Classificação: [Explique brevemente por que o conceito foi classificado dessa forma, referenciando o contexto RAG quando usado, ou explicando a lógica da classificação com base no seu conhecimento da CIF.]
+icf_gemini_prompt="""Você é um especialista na Classificação Internacional de Funcionalidade, Incapacidade e Saúde (CIF), uma ferramenta da OMS para descrever a saúde. Sua análise deve ser rigorosa, técnica e fundamentada nos princípios da CIF, tendo como principal referência as fontes fornecidas.
+
+**ESTRUTURA DOS INPUTS**
+
+Você receberá duas informações:
+- **[LISTA CIF]:** Um arquivo contendo a lista de referência da CIF. Utilize este documento como sua principal fonte de consulta para garantir a precisão dos códigos e definições.
+- **[ENTRADA DO USUÁRIO]:** O conteúdo a ser analisado (pode ser um texto simples ou um arquivo).
+
+**TAREFA PRINCIPAL**
+
+Sua tarefa é analisar o conteúdo fornecido em **[ENTRADA DO USUÁRIO]**:
+1.  Segmente o conteúdo em frases ou ideias centrais que permitem avaliar as condições de uma pessoa.
+2.  Para cada frase/ideia, realize o processo de classificação detalhado abaixo.
+
+**PROCESSO DE CLASSIFICAÇÃO**
+
+Para cada frase ou trecho relevante encontrado:
+1.  **Extração:** Recupere a frase original.
+2.  **Contextualização:** Identifique e resuma o "Contexto Significativo" (ideia central) da frase.
+3.  **Verificação de Cobertura:** Com base no seu conhecimento e consultando a **[LISTA CIF]**, determine se o Contexto Significativo está: "Coberto", "Não Coberto (N.C.)" ou "Não Definido (N.D.)".
+4.  **Classificação:** Se o status for "Coberto", identifique o código CIF e o título mais preciso, confirmando-os com o documento **[LISTA CIF]**.
+
+**ESTRUTURA E REGRAS RÍGIDAS DE SAÍDA**
+
+- **Formato Fixo:** Para cada análise, siga estritamente o formato abaixo.
+- **Separador:** Utilize `---` (três hífens) para separar cada análise completa.
+- **Sem Markdown:** A saída deve ser apenas em texto puro.
+
+**ESTRUTURA DE SAÍDA INDIVIDUAL:**
+
+Frase Extraída: [Trecho exato obtido do texto ou documento analisado]
+- Contexto Significativo: [Conceito significativo obtido do trecho]
+- Status da Cobertura: [Coberto; Não Coberto (N.C.); Não Definido (N.D.)]
+- Codificação CIF: [Se Coberto, insira o Código e o Título do código; N.C.; N.D.]
+- Justificativa: [Breve explicação da escolha do código e da cobertura]
+
+**EXEMPLO DE EXECUÇÃO PERFEITA:**
+
+*Input do Usuário:*: O paciente relata cansaço ao caminhar mais de um quarteirão.
+*Sua Saída Esperada:*
+Frase Extraída: O paciente relata cansaço ao caminhar mais de um quarteirão.
+- Contexto Significativo: Dificuldade para andar longas distâncias.
+- Status da Cobertura: Coberto
+- Codificação CIF: d450 Andar
+- Justificativa: A atividade de 'caminhar' é diretamente coberta pelo código d450, que se refere a andar distâncias variadas.
 """

utils/rag_retriever.py

@@ -9,23 +9,21 @@ from nltk import sent_tokenize
 import nltk
 
 # Baixar o tokenizador de frases do NLTK (necessário apenas uma vez)
-# try:
-#     print("tentanto encontrar o tokenizador de frases do NLTK...")
-#     nltk.data.find('tokenizers/punkt') or nltk.download('tokenizers/punkt_tab')
-# except nltk.downloader.DownloadError:
-#     print("Tokenizador de frases do NLTK não encontrado. Baixando...")
-#     nltk.download('punkt_tab')
-nltk.download("punkt")
+try:
+    print("tentanto encontrar o tokenizador de frases do NLTK...")
+    nltk.data.find('tokenizers/punkt') or nltk.download('tokenizers/punkt_tab')
+except nltk.downloader.DownloadError:
+    print("Tokenizador de frases do NLTK não encontrado. Baixando...")
+    nltk.download('punkt_tab')
 
 # Configurações
 # Configurações
-RAG_DIR = r".\RAG"
-DATA_DIR = os.path.join(RAG_DIR, "data")
-FAISS_INDEX_DIR = os.path.join(RAG_DIR, "FAISS")  # Renamed from FAISS_DIR for clarity
-CONTEXT_FAISS_INDEX_PATH = os.path.join(FAISS_INDEX_DIR, "context_index.faiss")  # Renamed variable
-CONTEXT_JSON_TEXT_PATH = os.path.join(FAISS_INDEX_DIR, "context_texts.json")  # Renamed variable
-EMBEDDING_MODEL_NAME = "nomic-ai/nomic-embed-text-v2-moe"  # Renamed variable
-
+RAG_DIR = r'.\RAG'
+DATA_DIR = os.path.join(RAG_DIR, 'data')
+FAISS_INDEX_DIR = os.path.join(RAG_DIR, 'FAISS') # Renamed from FAISS_DIR for clarity
+CONTEXT_FAISS_INDEX_PATH = os.path.join(FAISS_INDEX_DIR, 'context_index.faiss') # Renamed variable
+CONTEXT_JSON_TEXT_PATH = os.path.join(FAISS_INDEX_DIR, 'context_texts.json') # Renamed variable
+EMBEDDING_MODEL_NAME = 'nomic-ai/nomic-embed-text-v2-moe' # Renamed variable
 
 def _load_embedding_model() -> SentenceTransformer:
     """
@@ -40,7 +38,6 @@ def _load_embedding_model() -> SentenceTransformer:
     print(f"Carregando modelo de embeddings {EMBEDDING_MODEL_NAME}...")
     return SentenceTransformer(EMBEDDING_MODEL_NAME, trust_remote_code=True)
 
-
 def _load_existing_index_and_documents() -> tuple[list | None, faiss.Index | None]:
     """
     Attempts to load an existing FAISS index and its associated text documents
@@ -59,7 +56,7 @@ def _load_existing_index_and_documents() -> tuple[list | None, faiss.Index | Non
         print("Carregando índice e documentos existentes...")
         try:
             faiss_index = faiss.read_index(CONTEXT_FAISS_INDEX_PATH)
-            with open(CONTEXT_JSON_TEXT_PATH, "r", encoding="utf-8") as f:
+            with open(CONTEXT_JSON_TEXT_PATH, 'r', encoding='utf-8') as f:
                 loaded_documents = json.load(f)
             print(f"Carregados {len(loaded_documents)} documentos do índice existente.")
             return loaded_documents, faiss_index
@@ -68,7 +65,6 @@ def _load_existing_index_and_documents() -> tuple[list | None, faiss.Index | Non
             return None, None
     return None, None
 
-
 def _load_source_documents() -> list[str]:
     """
     Loads and preprocesses text documents from the data folder (DATA_DIR).
@@ -85,16 +81,16 @@ def _load_source_documents() -> list[str]:
         ValueError: If no '.txt' files are found in the data directory
                     or if no valid documents are loaded after processing.
     """
-    file_paths = glob.glob(os.path.join(DATA_DIR, "*.txt"))
+    file_paths = glob.glob(os.path.join(DATA_DIR, '*.txt'))
     if not file_paths:
         raise ValueError(f"Nenhum arquivo .txt encontrado em {DATA_DIR}. Por favor, adicione documentos.")
 
     context_chunks = []
     for file_path in file_paths:
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, 'r', encoding='utf-8') as f:
                 # Splits by double newline, strips whitespace, and filters out empty strings
-                context_chunks.extend(list(filter(None, map(str.strip, f.read().split("\n\n")))))
+                context_chunks.extend(list(filter(None, map(str.strip, f.read().split('\n\n')))))
         except Exception as e:
             print(f"Erro ao ler o arquivo {file_path}: {e}")
             continue
@@ -105,7 +101,6 @@ def _load_source_documents() -> list[str]:
     print(f"Carregados {len(context_chunks)} documentos.")
     return context_chunks
 
-
 def _generate_text_embeddings(embedder_model: SentenceTransformer, text_documents: list[str]) -> np.ndarray:
     """
     Generates numerical embeddings for a list of text documents using the provided embedder.
@@ -128,9 +123,9 @@ def _generate_text_embeddings(embedder_model: SentenceTransformer, text_document
     batch_size = 32
     generated_embeddings_list = []
     for i in range(0, len(text_documents), batch_size):
-        batch = text_documents[i : i + batch_size]
+        batch = text_documents[i:i + batch_size]
         try:
-            if batch:  # Ensure the batch is not empty
+            if batch: # Ensure the batch is not empty
                 generated_embeddings_list.extend(embedder_model.encode(batch, show_progress_bar=False))
         except Exception as e:
             print(f"Erro ao gerar embeddings para lote {i//batch_size if batch_size > 0 else i}: {e}")
@@ -143,7 +138,6 @@ def _generate_text_embeddings(embedder_model: SentenceTransformer, text_document
 
     return np.array(generated_embeddings_list, dtype=np.float32)
 
-
 def _create_faiss_index(document_embeddings: np.ndarray) -> faiss.Index:
     """
     Creates and populates a FAISS (Facebook AI Similarity Search) index from a set of embeddings.
@@ -165,7 +159,6 @@ def _create_faiss_index(document_embeddings: np.ndarray) -> faiss.Index:
     faiss_index.add(document_embeddings)
     return faiss_index
 
-
 def initialize_rag_system() -> tuple[list[str], faiss.Index, SentenceTransformer]:
     """
     Initializes the complete RAG (Retrieval Augmented Generation) system.
@@ -188,27 +181,20 @@ def initialize_rag_system() -> tuple[list[str], faiss.Index, SentenceTransformer
     text_embedder = _load_embedding_model()
     context_documents, faiss_index = _load_existing_index_and_documents()
 
-    if faiss_index is None:  # If the index doesn't exist or an error occurred loading it, rebuild
+    if faiss_index is None: # If the index doesn't exist or an error occurred loading it, rebuild
         print("Índice FAISS não encontrado ou corrompido. Reconstruindo...")
         context_documents = _load_source_documents()
         document_embeddings = _generate_text_embeddings(text_embedder, context_documents)
         faiss_index = _create_faiss_index(document_embeddings)
 
         faiss.write_index(faiss_index, CONTEXT_FAISS_INDEX_PATH)
-        with open(CONTEXT_JSON_TEXT_PATH, "w", encoding="utf-8") as f:
-            json.dump(context_documents, f, ensure_ascii=False, indent=4)  # Added indent for readability
+        with open(CONTEXT_JSON_TEXT_PATH, 'w', encoding='utf-8') as f:
+            json.dump(context_documents, f, ensure_ascii=False, indent=4) # Added indent for readability
         print("Novo índice e documentos salvos com sucesso.")
 
     return context_documents, faiss_index, text_embedder
 
-
-def search_with_full_query(
-    full_question_text: str,
-    context_documents: list[str],
-    faiss_index: faiss.Index,
-    embedder_model: SentenceTransformer,
-    k_results: int = 3,
-) -> list[tuple[int, str, float]]:
+def search_with_full_query(full_question_text: str, context_documents: list[str], faiss_index: faiss.Index, embedder_model: SentenceTransformer, k_results: int = 3) -> list[tuple[int, str, float]]:
     """
     Searches for the 'k_results' most relevant documents for the **entire question**,
     treating it as a single search unit. This function does not segment the question into sentences.
@@ -252,14 +238,7 @@ def search_with_full_query(
         print(f"Erro ao buscar contexto completo: {e}")
         return []
 
-
-def search_with_multiple_sentences(
-    question_text: str,
-    context_documents: list[str],
-    faiss_index: faiss.Index,
-    embedder_model: SentenceTransformer,
-    k_per_sentence: int = 2,
-) -> list[tuple[int, str, float]]:
+def search_with_multiple_sentences(question_text: str, context_documents: list[str], faiss_index: faiss.Index, embedder_model: SentenceTransformer, k_per_sentence: int = 2) -> list[tuple[int, str, float]]:
     """
     Segments the question into sentences and searches for the 'k_per_sentence' most relevant
     documents for **EACH sentence**, then consolidates and returns only unique contexts.
@@ -285,7 +264,7 @@ def search_with_multiple_sentences(
 
     print(f"Buscando múltiplos contextos para: '{question_text}'")
 
-    sentences = sent_tokenize(question_text, language="portuguese")
+    sentences = sent_tokenize(question_text, language='portuguese')
     if not sentences:
         print("Nenhuma frase detectada na pergunta para busca de múltiplos contextos.")
         return []
@@ -298,7 +277,7 @@ def search_with_multiple_sentences(
     try:
         for sentence in sentences:
             print(f"Processando frase para múltiplos contextos: '{sentence}'")
-            if not sentence.strip():  # Skip empty sentences that might be produced by sent_tokenize
+            if not sentence.strip(): # Skip empty sentences that might be produced by sent_tokenize
                 continue
             query_embedding = np.array(embedder_model.encode([sentence]), dtype=np.float32)
             distances, indices = faiss_index.search(query_embedding, k_per_sentence)
@@ -309,15 +288,8 @@ def search_with_multiple_sentences(
 
                 if 0 <= document_index < len(context_documents):
                     # If the document has already been found, update if the new distance is smaller (more relevant)
-                    if (
-                        document_index not in consolidated_contexts_map
-                        or distance_score < consolidated_contexts_map[document_index][2]
-                    ):
-                        consolidated_contexts_map[document_index] = (
-                            document_index,
-                            context_documents[document_index],
-                            distance_score,
-                        )
+                    if document_index not in consolidated_contexts_map or distance_score < consolidated_contexts_map[document_index][2]:
+                        consolidated_contexts_map[document_index] = (document_index, context_documents[document_index], distance_score)
 
         # Convert the dictionary of consolidated contexts back to a list
         results_list = list(consolidated_contexts_map.values())
@@ -330,7 +302,6 @@ def search_with_multiple_sentences(
         print(f"Erro ao buscar múltiplos contextos: {e}")
         return []
 
-
 # --- Funções de Teste ---
 def test_context_search_interactive():
     """
@@ -348,7 +319,7 @@ def test_context_search_interactive():
 
     while True:
         user_question = input("\nDigite uma pergunta (ou 'sair' para encerrar): ")
-        if user_question.lower() == "sair":
+        if user_question.lower() == 'sair':
             break
 
         print("\nEscolha o tipo de busca:")
@@ -357,16 +328,12 @@ def test_context_search_interactive():
         search_choice = input("Opção (1 ou 2): ")
 
         retrieved_contexts = []
-        if search_choice == "1":
+        if search_choice == '1':
             print(f"\nRealizando busca de contexto completo para: '{user_question}'")
-            retrieved_contexts = search_with_full_query(
-                user_question, context_documents, faiss_index, text_embedder, k_results=5
-            )
-        elif search_choice == "2":
+            retrieved_contexts = search_with_full_query(user_question, context_documents, faiss_index, text_embedder, k_results=5)
+        elif search_choice == '2':
             print(f"\nRealizando busca de múltiplos contextos para: '{user_question}'")
-            retrieved_contexts = search_with_multiple_sentences(
-                user_question, context_documents, faiss_index, text_embedder, k_per_sentence=3
-            )
+            retrieved_contexts = search_with_multiple_sentences(user_question, context_documents, faiss_index, text_embedder, k_per_sentence=3)
         else:
             print("Opção inválida. Tente novamente.")
             continue
@@ -378,9 +345,8 @@ def test_context_search_interactive():
         print("\nContextos mais relevantes:")
         for doc_idx, text_content, distance_score in retrieved_contexts:
             print(f"\nÍndice Original do Documento: {doc_idx}, Distância: {distance_score:.4f}")
-            print(f"Texto: {text_content[:500]}...")  # Limita o texto para melhor visualização
+            print(f"Texto: {text_content[:500]}...") # Limita o texto para melhor visualização
             print("-" * 50)
 
-
 if __name__ == "__main__":
-    test_context_search_interactive()
+    test_context_search_interactive()

utils/report/README.md

@@ -0,0 +1,3 @@
+# utils/report
+
+Aqui se armazena os códigos relacionados a geração de relatórios. Separa-se o tratamento de texto, de dataframe e de gráficos para sua união na interface gradio e no arquivo .pdf gerado.

utils/{dataframe_creation.py → report/dataframe_creation.py}

@@ -1,3 +1,4 @@
+# utils/report/dataframe_creation.py
 import re
 import pandas as pd
 from typing import Dict, Tuple, List
@@ -47,7 +48,6 @@ def _count_group_frequencies(llm_res: str) -> Dict[str, int]:
     print(f"Frequências por grupo atualizadas: {group_frequencies}")
     return group_frequencies
 
-
 def _count_individual_frequencies(llm_res: str) -> Dict[str, int]:
     """Conta a frequência de cada código CIF individualmente."""
     print("Contando frequências individuais...")

utils/{graph_creation.py → report/graph_creation.py}

@@ -1,7 +1,8 @@
+# utils/report/graph_creation.py
 import plotly.express as px
 import plotly.graph_objects as go
 import pandas as pd
-from typing import Optional # Dict e List não são mais necessários para as constantes globais
+from typing import Optional, Tuple # Dict e List não são mais necessários para as constantes globais
 
 # Importa a Enum para centralizar as definições de categoria, rótulos e cores
 from .icf_categories import ICFComponent
@@ -66,7 +67,6 @@ def create_pie_chart(
     )
     return figure
 
-
 def create_bar_chart(
     input_df: pd.DataFrame,
     title: str = "Frequência da Classificação"
@@ -120,7 +120,6 @@ def create_bar_chart(
     )
     return figure
 
-
 def create_tree_map_chart(
     tree_map_df: pd.DataFrame,
     title: str = "Treemap de Frequências por Hierarquia de Códigos"
@@ -176,4 +175,24 @@ def create_tree_map_chart(
             font_size=12,
         )
     )
-    return figure
+    return figure
+
+def create_report_plots(df_group: pd.DataFrame, df_individual_treemap: pd.DataFrame) -> Tuple[go.Figure, go.Figure, go.Figure]:
+    """
+    Cria as figuras Plotly dos gráficos a partir dos DataFrames processados.
+
+    Args:
+        df_group (pd.DataFrame): DataFrame de frequência por grupo CIF.
+        df_individual_treemap (pd.DataFrame): DataFrame para o treemap de códigos individuais.
+                                            (Esperado ter colunas: 'Filho', 'Parent', 'Frequencia')
+
+    Returns:
+        Tuple[go.Figure, go.Figure, go.Figure]: Figuras de pizza, barras e treemap.
+    """
+    print("Gerando gráficos...")
+    
+    fig_pie = create_pie_chart(df_group, title="Distribuição da Classificação por Componentes CIF")
+    fig_bar = create_bar_chart(df_group, title="Frequência da Classificação por Componentes CIF")
+    fig_tree_map = create_tree_map_chart(df_individual_treemap, title="Treemap de Frequência por Código CIF")
+    
+    return fig_pie, fig_bar, fig_tree_map

utils/{icf_categories.py → report/icf_categories.py}

@@ -1,3 +1,4 @@
+# utils/report/icf_categories.py
 from enum import Enum
 from typing import List, Dict
 

utils/{pdf_creation.py → report/pdf_creation.py}

@@ -1,3 +1,4 @@
+# utils/pdf_creation.py
 import io
 import re
 import os
@@ -18,28 +19,17 @@ _STRINGS = {
 }
 
 # --- Regex Patterns ---
-# Regex para identificar e tratar 'Frase de Entrada: ...'.
-_INPUT_PHRASE_REGEX = re.compile(r'^-?\s*(Frase de Entrada:.*)', re.IGNORECASE)
+# Regex para identificar e tratar (o acento pode ser problemático para llms as vezes) 'Frase de Extraída: ...'.
+
+_INPUT_PHRASE_REGEX = re.compile(r'^-?\s*(Frase Extra.*:.*)', re.IGNORECASE)
 
 # Regex para tratar itens de lista.
 # Captura caracteres válidos.
 _LIST_ITEM_CONTENT_REGEX = re.compile(r'^-?\s*(.*)')
 
-# --- Constantes para lidar com Plotlys ---
-_PLOT_IMAGE_COMMON_WIDTH_EXPORT = 800
-_PLOT_IMAGE_DEFAULT_HEIGHT_EXPORT = 500
-_PLOT_IMAGE_SPECIAL_HEIGHT_EXPORT = 800  # TreeMap
-_PLOT_IMAGE_SCALE = 2
-
-_PLOT_IMAGE_COMMON_DRAW_WIDTH = 550
-_PLOT_IMAGE_DEFAULT_DRAW_HEIGHT = 350
-_PLOT_IMAGE_SPECIAL_DRAW_HEIGHT = 550  # TreeMap
-
-_SPECIAL_PLOT_INDEX = 2 # TreeMap
-
 # --- Constants for Text Styling ---
 _LLM_RESPONSE_STARTERS = (
-    'resposta fornecida pela llm',
+    'Resposta Fornecida pela LLM',
 )
 
 def _handle_text_content(story: list, text_content: str, styles: dict) -> None:
@@ -95,13 +85,13 @@ def _handle_text_content(story: list, text_content: str, styles: dict) -> None:
     )
 
     # Timestamp & Disclaimer (gerado uma vez no início do conteúdo textual)
-    if not story: # Adiciona apenas se a story estiver vazia, para não repetir a cada chamada se a função for reutilizada
-        generation_timestamp_text = _STRINGS['TXT_TIMESTAMP'](datetime.now().strftime('%d-%m-%Y'))
-        story.append(Paragraph(generation_timestamp_text, h2_bold_centered_style))
+    # if not story: # Adiciona apenas se a story estiver vazia, para não repetir a cada chamada se a função for reutilizada
+    generation_timestamp_text = _STRINGS['TXT_TIMESTAMP'](datetime.now().strftime('%d-%m-%Y'))
+    story.append(Paragraph(generation_timestamp_text, h2_bold_centered_style))
 
-        disclaimer_text = _STRINGS['TXT_DISCLAIMER']
-        story.append(Paragraph(disclaimer_text, alert_message_style))
-        story.append(Spacer(1, 20))
+    disclaimer_text = _STRINGS['TXT_DISCLAIMER']
+    story.append(Paragraph(disclaimer_text, alert_message_style))
+    story.append(Spacer(1, 20))
 
     # Processamento do conteúdo principal
     text_blocks = text_content.split('---')
@@ -157,35 +147,36 @@ def _handle_text_content(story: list, text_content: str, styles: dict) -> None:
 
 
 def _handle_dataframe_content(story: list, dataframes_list: list[pd.DataFrame], styles: dict) -> None:
-    """
-    Adds pandas DataFrames to the PDF story, formatted as tables.
-
-    Each DataFrame is preceded by a page break and a title.
-    Table styling includes a header row with a grey background and white text,
-    and a beige background for data rows, with a grid.
+    """Adiciona DataFrames ao PDF, usando um dicionário interno para títulos descritivos."""
+    
+    # Dicionário que mapeia o índice do DataFrame ao seu título específico.
+    DATAFRAME_TITLES = {
+        0: "Tabela de Frequência por Componente CIF",
+        1: "Estatísticas Descritivas dos Componentes",
+        2: "Tabela de Frequência por Código CIF Específico",
+        3: "Estatísticas Descritivas dos Códigos CIF"
+    }
 
-    Args:
-        story (list): The list of ReportLab Platypus elements.
-        dataframes_list (list[pd.DataFrame]): A list of pandas DataFrames to include.
-        styles (dict): A dictionary of ReportLab sample paragraph styles.
-    """
     for df_index, df in enumerate(dataframes_list):
+        # Usa o título do dicionário se o índice existir; senão, usa um título genérico.
+        title = DATAFRAME_TITLES.get(df_index, f"Data (DataFrame {df_index + 1})")
+        
         story.append(PageBreak())
-        story.append(Paragraph(f"Data (DataFrame {df_index + 1}):", styles['h2']))
+        story.append(Paragraph(title, styles['h2']))
         story.append(Spacer(1, 1))
 
-        # Preparação do dataframe para tabela
+        # O restante da lógica para criar a tabela permanece o mesmo.
         table_data = [df.columns.tolist()] + df.values.tolist()
         pdf_table = Table(table_data)
 
         pdf_table.setStyle(TableStyle([
-            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),      # Header row background
-            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), # Header row text color
-            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),             # Center alignment for all cells
-            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),   # Header row font
-            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),            # Header row bottom padding
-            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),    # Data rows background
-            ('GRID', (0, 0), (-1, -1), 1, colors.black)        # Grid for the entire table
+            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.whitesmoke),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black)
         ]))
 
         story.append(pdf_table)
@@ -193,51 +184,57 @@ def _handle_dataframe_content(story: list, dataframes_list: list[pd.DataFrame],
 
 
 def _handle_plotly_plot(story: list, plotly_figures: list[go.Figure], styles: dict) -> None:
-    """
-    Converts Plotly figures to PNG images and adds them to the PDF story.
+    """Converte e adiciona gráficos Plotly, usando dicionários internos para títulos e configurações."""
+
+    # Dicionário que mapeia o índice do gráfico ao seu título.
+    PLOT_TITLES = {
+        0: "Distribuição Percentual por Componente",
+        1: "Gráfico de Frequência por Componente CIF",
+        2: "Análise Hierárquica de Códigos CIF (Treemap)"
+    }
+    
+    # Dicionário que mapeia o índice do gráfico a uma configuração especial.
+    PLOT_CONFIGS = {
+        2: {'type': 'treemap'}  # O gráfico de índice 2 é um treemap
+    }
 
-    Each plot is preceded by a page break and a title.
-    Handles potential errors during image conversion.
-    The third plot (index 2) has specific dimensions.
-
-    Args:
-        story (list): The list of ReportLab Platypus elements.
-        plotly_figures (list[go.Figure]): A list of Plotly Figure objects.
-        styles (dict): A dictionary of ReportLab sample paragraph styles.
-    """
     for fig_index, plotly_figure in enumerate(plotly_figures):
         try:
+            # Pega o título do dicionário, com fallback para o genérico.
+            title = PLOT_TITLES.get(fig_index, f"Generated Plot ({fig_index + 1})")
+            
+            # Pega a configuração do dicionário.
+            config = PLOT_CONFIGS.get(fig_index, {})
+            plot_type = config.get('type', 'default')
+
             image_buffer = io.BytesIO()
 
-            # Determine export and draw dimensions based on plot index
-            if fig_index == _SPECIAL_PLOT_INDEX:
-                export_height = _PLOT_IMAGE_SPECIAL_HEIGHT_EXPORT
-                draw_height = _PLOT_IMAGE_SPECIAL_DRAW_HEIGHT
+            # Determina as dimensões com base no 'type' obtido da configuração.
+            if plot_type == 'treemap':
+                export_height = 800 # _PLOT_IMAGE_SPECIAL_HEIGHT_EXPORT
+                draw_height = 550 # _PLOT_IMAGE_SPECIAL_DRAW_HEIGHT
             else:
-                export_height = _PLOT_IMAGE_DEFAULT_HEIGHT_EXPORT
-                draw_height = _PLOT_IMAGE_DEFAULT_DRAW_HEIGHT
+                export_height = 500 # _PLOT_IMAGE_DEFAULT_HEIGHT_EXPORT
+                draw_height = 350 # _PLOT_IMAGE_DEFAULT_DRAW_HEIGHT
 
             plotly_figure.write_image(
-                image_buffer,
-                format="png",
-                width=_PLOT_IMAGE_COMMON_WIDTH_EXPORT,
-                height=export_height,
-                scale=_PLOT_IMAGE_SCALE
+                image_buffer, format="png", width=800, # _PLOT_IMAGE_COMMON_WIDTH_EXPORT
+                height=export_height, scale=2 # _PLOT_IMAGE_SCALE
             )
             image_buffer.seek(0)
 
             reportlab_image = Image(image_buffer)
             reportlab_image.drawHeight = draw_height
-            reportlab_image.drawWidth = _PLOT_IMAGE_COMMON_DRAW_WIDTH
+            reportlab_image.drawWidth = 550 # _PLOT_IMAGE_COMMON_DRAW_WIDTH
 
             story.append(PageBreak())
-            story.append(Paragraph(f"Generated Plot ({fig_index + 1}):", styles['h2']))
+            story.append(Paragraph(title, styles['h2']))
             story.append(Spacer(1, 1))
             story.append(reportlab_image)
             story.append(Spacer(1, 4))
 
         except Exception as e:
-            error_message = f"Error adding Plotly plot {fig_index + 1}: {e}"
+            error_message = f"Error adding Plotly plot '{title}': {e}"
             story.append(Paragraph(error_message, styles['Normal']))
             story.append(Spacer(1, 2))
 

utils/{report_creation.py → report/report_creation.py}

@@ -1,36 +1,12 @@
+# utils/report/report_creation.py
 import plotly.graph_objects as go
 import pandas as pd # Ainda pode ser necessário para type hints ou manipulações leves
 from typing import Tuple # Remover Dict, Optional, List se não forem mais usados diretamente aqui
 
-from .graph_creation import create_pie_chart, create_bar_chart, create_tree_map_chart
+from .graph_creation import create_report_plots
 from .pdf_creation import generate_pdf_report_temp
 from .dataframe_creation import process_report_data
 
-# --- FUNÇÃO: Gera os gráficos a partir dos DataFrames ---
-def create_report_plots(df_group: pd.DataFrame, df_individual_treemap: pd.DataFrame) -> Tuple[go.Figure, go.Figure, go.Figure]:
-    """
-    Cria as figuras Plotly dos gráficos a partir dos DataFrames processados.
-
-    Args:
-        df_group (pd.DataFrame): DataFrame de frequência por grupo CIF.
-        df_individual_treemap (pd.DataFrame): DataFrame para o treemap de códigos individuais.
-                                            (Esperado ter colunas: 'Filho', 'Parent', 'Frequencia')
-
-    Returns:
-        Tuple[go.Figure, go.Figure, go.Figure]: Figuras de pizza, barras e treemap.
-    """
-    print("Gerando gráficos...")
-    
-    fig_pie = create_pie_chart(df_group, title="Distribuição da Classificação por Componentes CIF")
-    fig_bar = create_bar_chart(df_group, title="Frequência da Classificação por Componentes CIF")
-    
-    # Para o treemap, a função create_tree_map_chart precisa ser compatível com o DataFrame
-    # df_individual_treemap que agora inclui 'Filho', 'Parent', 'Subparent', 'Frequencia'.
-    # Ela usará 'Filho' como labels, 'Parent' (ou 'Subparent') como parents, e 'Frequencia' como values.
-    fig_tree_map = create_tree_map_chart(df_individual_treemap, title="Treemap de Frequência por Código CIF")
-    
-    return fig_pie, fig_bar, fig_tree_map
-
 # --- FUNÇÃO: Gera o PDF a partir de DataFrames e Figuras ---
 def generate_report_pdf(llm_res: str, df_group: pd.DataFrame, df_group_describe: pd.DataFrame, 
                         df_individual_treemap: pd.DataFrame, df_treemap_describe: pd.DataFrame,