Update routers/searchterm.py

routers/searchterm.py

@@ -117,60 +117,47 @@ def create_temp_file(data: Dict[str, Any]) -> Dict[str, str]:
     }
 
 
-async def generate_gemini_response(input_text: str) -> str:
-    """Gera resposta usando o modelo Gemini"""
+async def generate_search_terms(context: str) -> List[str]:
+    """Gera termos de pesquisa usando o modelo Gemini"""
     try:
         client = genai.Client(api_key=GEMINI_API_KEY)
         model = "gemini-2.5-flash-lite"
         
+        system_prompt = """Com base num contexto inicial, gere termos de pesquisa (até 20 termos, no máximo), em um JSON. Esses textos devem ser interpretados como termos que podem ser usados por outras inteligências artificiais pra pesquisar no google e retornar resultados mais refinados e completos pra busca atual. Analise muito bem o contexto, por exemplo, se está falando de uma série coreana, gere os termos em coreano por que obviamente na mídia coreana terá mais cobertura que a americana, etc.
+
+Deve seguir esse formato: "terms": []
+
+Retorne apenas o JSON, sem mais nenhum texto."""
+
         contents = [
             types.Content(
                 role="user",
                 parts=[
-                    types.Part.from_text(text="Retorne um json de exemplo"),
+                    types.Part.from_text(text="Contexto: Taylor Sheridan's 'Landman' Announces Season 2 Premiere Date"),
                 ],
             ),
             types.Content(
                 role="model",
                 parts=[
-                    types.Part.from_text(text="""Com certeza! Aqui está um exemplo de JSON simples:
-```json
-{
-  \"nome\": \"Maria Silva\",
-  \"idade\": 30,
-  \"profissao\": \"Engenheira de Software\",
-  \"habilidades\": [
-    \"Python\",
-    \"JavaScript\",
-    \"SQL\",
-    \"Docker\"
-  ],
-  \"contato\": {
-    \"email\": \"[email protected]\",
-    \"telefone\": \"+55 11 98765-4321\"
-  },
-  \"ativo\": true,
-  \"projetos\": null
-}
-```
-**Explicação dos elementos:**
-*   **`{}`**: Representa um objeto JSON.
-*   **`\"chave\": valor`**: Um objeto é composto por pares de chave-valor.
-    *   As **chaves** são sempre strings, delimitadas por aspas duplas.
-    *   Os **valores** podem ser de diversos tipos:
-        *   **String:** ` \"Maria Silva\" ` (delimitada por aspas duplas)
-        *   **Número:** ` 30 ` (inteiro ou decimal)
-        *   **Booleano:** ` true ` ou ` false `
-        *   **Array (Lista):** ` [\"Python\", \"JavaScript\", \"SQL\", \"Docker\"] ` (uma lista de valores, delimitada por colchetes `[]`, onde os elementos são separados por vírgulas)
-        *   **Objeto:** ` {\"email\": \"[email protected]\", \"telefone\": \"+55 11 98765-4321\"} ` (outro objeto JSON aninhado)
-        *   **`null`**: Representa a ausência de valor.
-Este é um exemplo bastante comum e demonstra a estrutura básica do JSON."""),
+                    types.Part.from_text(text='{"terms": [ "imdb landman episodes season 2", "imdb landman series", "landman season 2 release date", "taylor sheridan landman series", "landman season 2 cast sam elliott", "billy bob thornton returns landman", "demi moore landman new season", "andy garcia ali larter landman season 2", "landman texas oil drama", "taylor sheridan tv series schedule", "landman 10 month turnaround new episodes", "landman season 2 november 16 premiere", "sam elliott joins taylor sheridan show", "landman streaming platform premiere", "landman season 2 filming details", "landman new cast and returning actors", "taylor sheridan quick tv show production" ]}'),
                 ],
             ),
             types.Content(
                 role="user",
                 parts=[
-                    types.Part.from_text(text=input_text),
+                    types.Part.from_text(text="Contexto: Pixar's latest animated feature will arrive on digital (via platforms like Apple TV, Amazon Prime Video, and Fandango at Home) on Aug. 19 and on physical media (4K UHD, Blu-ray and DVD) on Sept. 9. The film has not yet set a Disney+ streaming release date, but that will likely come after the Blu-ray release."),
+                ],
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text='{ "terms": [ "pixar elio 2024 movie details", "disney pixar new release elio", "elio animated film august 19 digital", "pixar sci-fi comedy elio home release", "elio movie blu-ray dvd release september", "where to watch elio online", "elio streaming disney plus release date", "elio digital release apple tv amazon prime", "elio physical media 4k uhd blu-ray dvd", "elio movie bonus features", "elio cast voice actors", "elio behind the scenes making of", "elio deleted scenes blu-ray", "elio soundtrack and score", "elio merchandise release date", "upcoming disney pixar movies 2024", "pixar elio critical reviews", "elio movie box office results" ] }'),
+                ],
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=f"Contexto: {context}"),
                 ],
             ),
         ]
@@ -191,10 +178,35 @@ Este é um exemplo bastante comum e demonstra a estrutura básica do JSON."""),
             if chunk.text:
                 full_response += chunk.text
         
-        return full_response
+        # Tenta extrair o JSON da resposta
+        try:
+            # Remove possíveis ```json e ``` da resposta
+            clean_response = full_response.strip()
+            if clean_response.startswith("```json"):
+                clean_response = clean_response[7:]
+            if clean_response.endswith("```"):
+                clean_response = clean_response[:-3]
+            clean_response = clean_response.strip()
+            
+            # Parse do JSON
+            response_data = json.loads(clean_response)
+            terms = response_data.get("terms", [])
+            
+            # Validação básica
+            if not isinstance(terms, list):
+                raise ValueError("Terms deve ser uma lista")
+            
+            return terms[:20]  # Garante máximo de 20 termos
+            
+        except (json.JSONDecodeError, ValueError) as e:
+            print(f"Erro ao parsear resposta do Gemini: {e}")
+            print(f"Resposta recebida: {full_response}")
+            # Retorna uma lista vazia em caso de erro
+            return []
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erro ao gerar resposta do Gemini: {str(e)}")
+        print(f"Erro ao gerar termos de pesquisa: {str(e)}")
+        return []
 
 
 async def search_brave_term(client: httpx.AsyncClient, term: str) -> List[Dict[str, str]]:
@@ -261,10 +273,19 @@ async def extract_article_text(url: str, session: aiohttp.ClientSession) -> str:
 
 
 @router.post("/search-terms")
-async def search_terms(payload: Dict[str, List[str]] = Body(...)) -> Dict[str, Any]:
-    terms = payload.get("terms")
-    if not terms or not isinstance(terms, list):
-        raise HTTPException(status_code=400, detail="Campo 'terms' é obrigatório e deve ser uma lista.")
+async def search_terms(payload: Dict[str, str] = Body(...)) -> Dict[str, Any]:
+    context = payload.get("context")
+    if not context or not isinstance(context, str):
+        raise HTTPException(status_code=400, detail="Campo 'context' é obrigatório e deve ser uma string.")
+    
+    if len(context.strip()) == 0:
+        raise HTTPException(status_code=400, detail="Campo 'context' não pode estar vazio.")
+    
+    # Gera os termos de pesquisa usando o Gemini
+    terms = await generate_search_terms(context)
+    
+    if not terms:
+        raise HTTPException(status_code=500, detail="Não foi possível gerar termos de pesquisa válidos.")
 
     used_urls = set()
     search_semaphore = asyncio.Semaphore(20)
@@ -326,55 +347,12 @@ async def search_terms(payload: Dict[str, List[str]] = Body(...)) -> Dict[str, A
     return {
         "message": "Dados salvos em arquivo temporário",
         "total_results": len(final_results),
+        "context": context,
+        "generated_terms": terms,
         "file_info": temp_file_info
     }
 
 
-@router.post("/inference/terms")
-async def inference_terms(payload: Dict[str, str] = Body(...)) -> Dict[str, Any]:
-    """
-    Endpoint para fazer inferência com o modelo Gemini
-    
-    Body:
-    {
-        "input": "Sua pergunta ou texto aqui"
-    }
-    """
-    input_text = payload.get("input")
-    
-    if not input_text or not isinstance(input_text, str):
-        raise HTTPException(
-            status_code=400, 
-            detail="Campo 'input' é obrigatório e deve ser uma string."
-        )
-    
-    if len(input_text.strip()) == 0:
-        raise HTTPException(
-            status_code=400, 
-            detail="Campo 'input' não pode estar vazio."
-        )
-    
-    try:
-        # Gera resposta usando o Gemini
-        response = await generate_gemini_response(input_text)
-        
-        return {
-            "input": input_text,
-            "response": response,
-            "model": "gemini-2.5-flash-lite",
-            "timestamp": time.time()
-        }
-        
-    except HTTPException:
-        # Re-raise HTTPExceptions para manter o status code correto
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, 
-            detail=f"Erro interno do servidor: {str(e)}"
-        )
-
-
 @router.get("/download-temp/{file_id}")
 async def download_temp_file(file_id: str):
     """Endpoint para download do arquivo temporário"""
@@ -393,23 +371,4 @@ async def download_temp_file(file_id: str):
         filename="fontes.txt",
         media_type="text/plain",
         headers={"Content-Disposition": "attachment; filename=fontes.txt"}
-    )
-
-
-@router.get("/temp-files/status")
-async def get_temp_files_status():
-    """Endpoint para verificar status dos arquivos temporários (debug)"""
-    status = {}
-    current_time = time.time()
-    
-    for file_id, info in temp_files.items():
-        age_hours = (current_time - info["created_at"]) / 3600
-        remaining_hours = max(0, 24 - age_hours)
-        
-        status[file_id] = {
-            "age_hours": round(age_hours, 2),
-            "remaining_hours": round(remaining_hours, 2),
-            "exists": info["path"].exists()
-        }
-    
-    return {"temp_files": status}
+    )