feat: adicionar gerador de ementa

_utils/gerar_documento_utils/GerarDocumento.py

@@ -247,31 +247,14 @@ class GerarDocumento:
 
             llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
             prompt_instance = Prompt()
-            documento_gerado = ""
-            tentativas = 0
             context_do_prompt_primeira_etapa = "\n\n".join(contexts)
             prompt_primeira_etapa = prompt_gerar_documento.format(
                 context=context_do_prompt_primeira_etapa,
             )
 
-            while tentativas < 5 and not documento_gerado:
-                tentativas += 1
-                resposta = llm.invoke(prompt_primeira_etapa)
-                if hasattr(resposta, "content") and resposta.content.strip():  # type: ignore
-                    documento_gerado = resposta.content.strip()  # type: ignore
-                else:
-                    print(f"Tentativa {tentativas}: resposta vazia ou inexistente.")
-                    time.sleep(5)
-
-            if not documento_gerado:
-                self.axiom_instance.send_axiom(
-                    "TENTANDO GERAR DOCUMENTO FINAL COM GPT 4o-mini COMO ÚLTIMA TENTATIVA"
-                )
-                documento_gerado = (
-                    self.gerar_documento_utils.ultima_tentativa_requisicao(
-                        prompt_primeira_etapa
-                    )
-                )
+            documento_gerado = await self.checar_se_resposta_vazia_do_documento_final(
+                llm_ultimas_requests, prompt_primeira_etapa
+            )
 
             texto_final_juntando_as_etapas = ""
             resposta_primeira_etapa = documento_gerado
@@ -318,3 +301,29 @@ class GerarDocumento:
         except Exception as e:
             self.logger.error(f"Error generating enhanced summary: {str(e)}")
             raise
+
+    async def checar_se_resposta_vazia_do_documento_final(
+        self, llm_ultimas_requests: str, prompt: str
+    ):
+        llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
+        documento_gerado = ""
+        tentativas = 0
+
+        while tentativas < 5 and not documento_gerado:
+            tentativas += 1
+            resposta = llm.invoke(prompt)
+            if hasattr(resposta, "content") and resposta.content.strip():  # type: ignore
+                documento_gerado = resposta.content.strip()  # type: ignore
+            else:
+                print(f"Tentativa {tentativas}: resposta vazia ou inexistente.")
+                time.sleep(5)
+
+        if not documento_gerado:
+            self.axiom_instance.send_axiom(
+                "TENTANDO GERAR DOCUMENTO FINAL COM GPT 4o-mini COMO ÚLTIMA TENTATIVA"
+            )
+            documento_gerado = self.gerar_documento_utils.ultima_tentativa_requisicao(
+                prompt
+            )
+
+        return documento_gerado

_utils/gerar_documento_utils/contextual_retriever.py

@@ -274,7 +274,6 @@ class ContextualRetrieverUtils:
         resultado = None
         for pattern in patterns:
             matches: List[str] = re.findall(pattern, context, re.DOTALL)
-            print("\n\nmatches", matches)
             condition_tuples_3_items = all(len(m) == 3 for m in matches)
             if len(matches) == len(lista_de_document_ids) and condition_tuples_3_items:
                 print("\n--------------- REGEX DO CONTEXTUAL FUNCIONOU")

_utils/gerar_documento_utils/utils.py

@@ -11,6 +11,9 @@ from _utils.gerar_documento_utils.prompts import (
 
 from _utils.models.gerar_documento import DocumentChunk
 from gerar_documento.serializer import GerarDocumentoSerializerData
+import tiktoken
+
+encoding = tiktoken.get_encoding("cl100k_base")
 
 
 def gerar_resposta_compilada(serializer: Union[GerarDocumentoSerializerData, Any]):
@@ -37,9 +40,6 @@ def gerar_resposta_compilada(serializer: Union[GerarDocumentoSerializerData, Any
 
 # Esta função gera a resposta que será usada em cada um das requisições de cada chunk
 async def get_response_from_auxiliar_contextual_prompt(full_text_as_array: List[str]):
-    import tiktoken
-
-    encoding = tiktoken.get_encoding("cl100k_base")
     llms = LLM()
     responses = []
 
@@ -86,12 +86,27 @@ async def get_response_from_auxiliar_contextual_prompt(full_text_as_array: List[
     return "".join(responses)
 
 
+def split_text_by_tokens(full_text: str):
+    tokens = encoding.encode(full_text)
+    max_tokens = 60000
+
+    # Divide os tokens em partes de no máximo max_tokens
+    token_chunks = [
+        tokens[i : i + max_tokens] for i in range(0, len(tokens), max_tokens)
+    ]
+
+    # Decodifica cada pedaço de tokens de volta para texto
+    text_chunks = [encoding.decode(chunk) for chunk in token_chunks]
+
+    return text_chunks
+
+
 async def get_full_text_and_all_PDFs_chunks(
     listaPDFs: List[str],
     splitterObject: Splitter,
     should_use_llama_parse: bool,
     isBubble: bool,
-):
+) -> Tuple[List[DocumentChunk], List[str]]:
     all_PDFs_chunks: List[DocumentChunk] = []
 
     pages: List[str] = []

gerar_documento/views.py

@@ -1,11 +1,17 @@
 from typing import Any, Dict, cast
 from langchain.prompts import PromptTemplate
+from _utils.bubble_integrations.enviar_resposta_final import enviar_resposta_final
+from _utils.custom_exception_handler import custom_exception_handler_wihout_api_handler
+from _utils.gerar_documento_utils.GerarDocumento import GerarDocumento
 from _utils.langchain_utils.LLM_class import LLM
 from _utils.gerar_documento_utils.utils import (
+    generate_document_title,
+    gerar_resposta_compilada,
     get_full_text_and_all_PDFs_chunks,
+    split_text_by_tokens,
 )
 from _utils.langchain_utils.Prompt_class import Prompt
-from _utils.utils import print_sentry, sentry_add_breadcrumb
+from _utils.utils import convert_markdown_to_HTML, print_sentry, sentry_add_breadcrumb
 from setup.easy_imports import (
     Response,
     AsyncAPIView,
@@ -40,8 +46,9 @@ class GerarDocumentoView(AsyncAPIView):
     async def post(self, request):
         self.axiom_instance.generate_new_uuid()
         print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
-        self.axiom_instance.send_axiom("COMEÇOU NOVA REQUISIÇÃO")
-        self.axiom_instance.send_axiom(f"request.data: {request.data}")
+        self.axiom_instance.send_axiom(
+            f"COMEÇOU NOVA REQUISIÇÃO - request.data: {request.data}"
+        )
         serializer = GerarDocumentoSerializer(data=request.data)
         if serializer.is_valid(raise_exception=True):
             obj = serializer.get_obj()  # type: ignore
@@ -125,43 +132,82 @@ class GerarEmentaView(AsyncAPIView):
         )
         serializer = GerarDocumentoSerializer(data=request.data)
         if serializer.is_valid(raise_exception=True):
+            obj = serializer.get_obj()  # type: ignore
             if not serializer.validated_data:
                 raise ValueError("Erro no validated_data")
 
             async def proccess_data_after_response():
-                data = cast(Dict[str, Any], serializer.validated_data)
-                serializer_obj = serializer.get_obj()
-                self.serializer = data
+                try:
+                    data = cast(Dict[str, Any], serializer.validated_data)
+                    self.serializer = data
 
-                listaPDFs = [l["link_arquivo"] for l in data["files"]]
-                self.axiom_instance.send_axiom(
-                    f"listaPDFs: {listaPDFs}",
-                )
+                    gerar_documento_instance = GerarDocumento(obj, self.axiom_instance)
 
-                all_PDFs_chunks, full_text_as_array = (
-                    await get_full_text_and_all_PDFs_chunks(
-                        listaPDFs,
-                        Splitter(
-                            serializer_obj.chunk_size, serializer_obj.chunk_overlap
-                        ),
-                        False,
-                        True,
+                    listaPDFs = [l["link_arquivo"] for l in data["files"]]
+
+                    self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
+
+                    all_PDFs_chunks, full_text_as_array = (
+                        await get_full_text_and_all_PDFs_chunks(
+                            listaPDFs,
+                            Splitter(obj.chunk_size, obj.chunk_overlap),
+                            False,
+                            True,
+                        )
+                    )
+                    full_text = "".join(full_text_as_array)
+                    self.axiom_instance.send_axiom(
+                        f"full_text[0:100] gerado do PDF: {full_text[0:100]}"
                     )
-                )
-                full_text = "".join(full_text_as_array)
-                self.axiom_instance.send_axiom(
-                    f"full_text gerado dos pdfs: {full_text}"
-                )
 
-                llm = LLM()
-                prompt_template = PromptTemplate(
-                    input_variables=["context"], template=full_text
-                )
-                response = await llm.google_gemini().ainvoke(
-                    prompt_template.format(context=full_text)
-                )
+                    texto_completo = ""
+                    text_splitted_by_tokens = split_text_by_tokens(full_text)
+                    for text in text_splitted_by_tokens:
+                        prompt_template = PromptTemplate(
+                            input_variables=["context"], template=obj.user_message
+                        )
+                        texto_da_parte = await gerar_documento_instance.checar_se_resposta_vazia_do_documento_final(
+                            obj.llm_ultimas_requests,
+                            prompt_template.format(context=text),
+                        )
+
+                        texto_completo += texto_da_parte
+
+                    texto_completo_como_html = convert_markdown_to_HTML(
+                        texto_completo
+                    ).replace("resposta_segunda_etapa:", "<br><br>")
+                    self.axiom_instance.send_axiom(
+                        f"resposta_llm: {texto_completo_como_html}"
+                    )
 
-                print("\n\nresposta_llm: ", response.content)
+                    titulo_do_documento = await generate_document_title(
+                        cast(str, texto_completo_como_html)
+                    )
+
+                    self.axiom_instance.send_axiom(
+                        "PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO"
+                    )
+
+                    self.axiom_instance.send_axiom(
+                        "COMEÇANDO A REQUISIÇÃO FINAL PARA O BUBBLE"
+                    )
+                    enviar_resposta_final(
+                        obj.doc_id,  # type: ignore
+                        obj.form_response_id,  # type: ignore
+                        obj.version,  # type: ignore
+                        texto_completo_como_html,
+                        False,
+                        cast(str, titulo_do_documento),
+                    )
+                    self.axiom_instance.send_axiom(
+                        "TERMINOU A REQUISIÇÃO FINAL PARA O BUBBLE"
+                    )
+                except Exception as e:
+                    print(f"ERRO GERAR EMENTA: {e}")
+                    custom_exception_handler_wihout_api_handler(
+                        e, serializer, self.axiom_instance
+                    )
+                    raise
 
             # asyncio.create_task(proccess_data_after_response())
             loop = asyncio.get_running_loop()
@@ -193,10 +239,11 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
             data = cast(Dict[str, Any], serializer.validated_data)
             self.axiom_instance.send_axiom(f"data: {data}")
             self.serializer = data
-
-            data = cast(Dict[str, Any], serializer.validated_data)
             serializer_obj = serializer.get_obj()
-            self.serializer = data
+
+            gerar_documento_instance = GerarDocumento(
+                serializer_obj, self.axiom_instance
+            )
 
             listaPDFs = handle_pdf_files_from_serializer(
                 data["files"], self.axiom_instance
@@ -208,7 +255,7 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
                     listaPDFs,
                     Splitter(serializer_obj.chunk_size, serializer_obj.chunk_overlap),
                     False,
-                    True,
+                    False,
                 )
             )
             full_text = "".join(full_text_as_array)
@@ -216,18 +263,36 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
                 f"full_text[0:100] gerado do PDF: {full_text[0:100]}"
             )
 
-            llm = LLM()
-            prompt_template = PromptTemplate(
-                input_variables=["context"], template=full_text
-            )
-            response = await llm.google_gemini().ainvoke(
-                prompt_template.format(context=full_text)
+            texto_completo = ""
+            text_splitted_by_tokens = split_text_by_tokens(full_text)
+            for text in text_splitted_by_tokens:
+                prompt_template = PromptTemplate(
+                    input_variables=["context"], template=serializer_obj.user_message
+                )
+                texto_da_parte = await gerar_documento_instance.checar_se_resposta_vazia_do_documento_final(
+                    serializer_obj.llm_ultimas_requests,
+                    prompt_template.format(context=text),
+                )
+
+                texto_completo += texto_da_parte
+
+            texto_completo_como_html = convert_markdown_to_HTML(texto_completo).replace(
+                "resposta_segunda_etapa:", "<br><br>"
             )
+            self.axiom_instance.send_axiom(f"resposta_llm: {texto_completo_como_html}")
 
-            self.axiom_instance.send_axiom(f"resposta_llm: {response.content}")
+            titulo_do_documento = await generate_document_title(
+                cast(str, texto_completo_como_html)
+            )
 
             remove_pdf_temp_files(listaPDFs)
             self.axiom_instance.send_axiom(
                 "PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO"
             )
-            return Response({"resposta": response.content})
+
+            return Response(
+                {
+                    "texto_completo": texto_completo_como_html,
+                    "titulo_do_documento": titulo_do_documento,
+                }
+            )