Update main.py

main.py

@@ -743,8 +743,8 @@ async def process_account_endpoint(account: str):
         t_start = time.time()
         record = records[0]
         record_id = record.get("id")
-        print(f"🚀 [0.0s] Inciando processamento da conta '{account}' para Record: {record_id}")
         video_url = record.get("ig_post_url")
+        crop_url = record.get("crop_content_url")
         context = record.get("ig_caption", "")
         comments = record.get("comments") # Se existir no banco, pode ser uma lista
         contains_image = record.get("contains_image", False)
@@ -777,8 +777,8 @@ async def process_account_endpoint(account: str):
         except Exception as _e:
             print(f"⚠️ Erro ao enviar notificação de início para o Discord: {_e}")
 
-        print(f"📥 Baixando vídeo para processamento: {video_url}")
-        response = download_file_with_retry(video_url, timeout=600)
+        print(f"📥 Baixando vídeo para processamento: {crop_url if crop_url else video_url}")
+        response = download_file_with_retry(crop_url if crop_url else video_url, timeout=600)
         content_type = response.headers.get('content-type', '').lower()
         if 'image' in content_type:
             if 'png' in content_type: ext = '.png'
@@ -795,55 +795,78 @@ async def process_account_endpoint(account: str):
 
         video_path_to_analyze = temp_file.name
         files_to_send = [] # Ordem: [cropped, original]
+        temp_file_original = None
 
-        if 'image' in content_type:
-            print(f"✂️ [{time.time()-t_start:.1f}s] Processando imagem: detectando e cortando...")
+        # 3. Lógica de Crop (Pular se já baixamos a versão cortada)
+        if crop_url:
+            print(f"✨ [{time.time()-t_start:.1f}s] Usando vídeo já cortado (crop_content_url). Pulando processamento de crop.")
+            cropped_video_path = video_path_to_analyze
+            files_to_send.append(cropped_video_path)
+            
+            # Adicionar o original como segundo anexo para contexto
+            print(f"📥 [{time.time()-t_start:.1f}s] Baixando vídeo original para contexto Gemini...")
             try:
-                cropped_file_path = detect_and_crop_image(video_path_to_analyze)
-                if cropped_file_path and os.path.exists(cropped_file_path):
-                    files_to_send.append(cropped_file_path)
+                orig_resp = download_file_with_retry(video_url, timeout=300)
+                orig_temp = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
+                for chunk in orig_resp.iter_content(chunk_size=1024*1024):
+                    if chunk: orig_temp.write(chunk)
+                orig_temp.close()
+                files_to_send.append(orig_temp.name)
+                # Adicionar à lista de limpeza final
+                temp_file_original = orig_temp # Guardar para cleanup
             except Exception as e:
-                print(f"⚠️ Erro ao cortar imagem: {e}")
+                print(f"⚠️ Não foi possível baixar o vídeo original para contexto: {e}")
         else:
-            # Vídeo: detectar e cortar bordas estáticas
-            print(f"✂️ [{time.time()-t_start:.1f}s] Processando vídeo: detectando e cortando bordas...")
-            try:
-                cropped_video_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
-                crop_status = detect_and_crop_video(video_path_to_analyze, cropped_video_path)
-                
-                if crop_status == "aborted_area_too_small":
-                    print(f"🚫 [{time.time()-t_start:.1f}s] Crop abortado: área de texto no centro. Negando filtro.")
-                    requests.patch(f"{supabase_url}/rest/v1/posts?id=eq.{record_id}", headers=headers, json={
-                        "approved_filter": False,
-                        "result": {"error": "Rejeitado: Região útil de texto insuficiente para crop seguro (texto centralizado)."}
-                    })
-                    return {"status": "rejected", "message": "Postagem rejeitada por crop insuficiente."}
-
-                if crop_status == "success" and os.path.exists(cropped_video_path):
-                    files_to_send.append(cropped_video_path)
-                    print(f"✅ [{time.perf_counter()-t_start:.1f}s] Vídeo cortado com sucesso.")
+            # Lógica tradicional de crop
+            if 'image' in content_type:
+                print(f"✂️ [{time.time()-t_start:.1f}s] Processando imagem: detectando e cortando...")
+                try:
+                    cropped_file_path = detect_and_crop_image(video_path_to_analyze)
+                    if cropped_file_path and os.path.exists(cropped_file_path):
+                        files_to_send.append(cropped_file_path)
+                except Exception as e:
+                    print(f"⚠️ Erro ao cortar imagem: {e}")
+            else:
+                # Vídeo: detectar e cortar bordas estáticas
+                print(f"✂️ [{time.time()-t_start:.1f}s] Processando vídeo: detectando e cortando bordas...")
+                try:
+                    cropped_video_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+                    crop_status = detect_and_crop_video(video_path_to_analyze, cropped_video_path)
                     
-                    # Upload antecipado para recurve-save (Performance)
-                    print(f"☁️ [{time.time()-t_start:.1f}s] Enviando vídeo cortado antecipadamente para recurve-save...")
-                    with open(cropped_video_path, 'rb') as vf:
-                        vid_upload_resp = requests.post(
-                            "https://habulaj-recurve-save.hf.space/upload",
-                            files={'files': ('cropped_video.mp4', vf, 'video/mp4')},
-                            data={'long_duration': 'yes'},
-                            timeout=120
-                        )
-                        vid_upload_resp.raise_for_status()
-                    cropped_video_url = vid_upload_resp.json().get("url", "")
-                    print(f"✅ [{time.time()-t_start:.1f}s] URL do vídeo cortado: {cropped_video_url}")
-                else:
+                    if crop_status == "aborted_area_too_small":
+                        print(f"🚫 [{time.time()-t_start:.1f}s] Crop abortado: área de texto no centro. Negando filtro.")
+                        requests.patch(f"{supabase_url}/rest/v1/posts?id=eq.{record_id}", headers=headers, json={
+                            "approved_filter": False,
+                            "result": {"error": "Rejeitado: Região útil de texto insuficiente para crop seguro (texto centralizado)."}
+                        })
+                        return {"status": "rejected", "message": "Postagem rejeitada por crop insuficiente."}
+
+                    if crop_status == "success" and os.path.exists(cropped_video_path):
+                        files_to_send.append(cropped_video_path)
+                        print(f"✅ [{time.perf_counter()-t_start:.1f}s] Vídeo cortado com sucesso.")
+                        
+                        # Upload antecipado para recurve-save (Performance)
+                        print(f"☁️ [{time.time()-t_start:.1f}s] Enviando vídeo cortado antecipadamente para recurve-save...")
+                        with open(cropped_video_path, 'rb') as vf:
+                            vid_upload_resp = requests.post(
+                                "https://habulaj-recurve-save.hf.space/upload",
+                                files={'files': ('cropped_video.mp4', vf, 'video/mp4')},
+                                data={'long_duration': 'yes'},
+                                timeout=120
+                            )
+                            vid_upload_resp.raise_for_status()
+                        cropped_video_url = vid_upload_resp.json().get("url", "")
+                        print(f"✅ [{time.time()-t_start:.1f}s] URL do vídeo cortado: {cropped_video_url}")
+                    else:
+                        cropped_video_path = None
+                        print(f"⚠️ [{time.time()-t_start:.1f}s] Crop de vídeo não gerou resultado, seguindo com original apenas")
+                except Exception as e:
                     cropped_video_path = None
-                    print(f"⚠️ [{time.time()-t_start:.1f}s] Crop de vídeo não gerou resultado, seguindo com original apenas")
-            except Exception as e:
-                cropped_video_path = None
-                print(f"⚠️ Erro ao cortar vídeo: {e}")
-        
-        # Adiciona o vídeo original (sempre em segundo se houver crop)
-        files_to_send.append(video_path_to_analyze)
+                    print(f"⚠️ Erro ao cortar vídeo: {e}")
+            
+            # Adiciona o vídeo original (sempre em segundo se houver crop)
+            files_to_send.append(video_path_to_analyze)
+
         contexto_add = f"\n{context}" if context else ""
         comentarios_add = ""
         if comments:
@@ -1418,20 +1441,58 @@ async def run_filter_account(account: str):
             if chunk: temp_file.write(chunk)
         media_path_to_analyze = temp_file.name
         cropped_file_path = None
+        crop_content_url = None
         
-        # ... logic continues inside the function
-        
-        # Se for imagem, faz o crop e prepara dois anexos
+        # 3. Crop (Filtro Inteligente)
         if 'image' in content_type:
             print(f"✂️ Processando imagem: detectando e cortando...")
             try:
-                cropped_file_path = detect_and_crop_image(temp_file.name)
+                cropped_file_path = detect_and_crop_image(media_path_to_analyze)
             except Exception as e:
                 print(f"⚠️ Erro ao cortar imagem: {e}")
-        
-        files_to_send = [temp_file.name]
+        else:
+            print(f"✂️ Processando vídeo: detectando e cortando bordas...")
+            try:
+                # Criar arquivo temporário para o vídeo cortado
+                cropped_video_tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+                crop_status = detect_and_crop_video(media_path_to_analyze, cropped_video_tmp)
+                
+                if crop_status == "aborted_area_too_small":
+                    print(f"🚫 Crop abortado: área de texto no centro. Reprovando filtro.")
+                    requests.patch(f"{supabase_url}/rest/v1/posts?id=eq.{record_id}", headers=headers, json={
+                        "approved_filter": False,
+                        "filter_message": "Rejeitado automaticamente: Região útil de texto insuficiente para crop seguro (texto centralizado no vídeo).",
+                        "contains_image": False
+                    })
+                    return # Para o processamento aqui
+                
+                if crop_status == "success" and os.path.exists(cropped_video_tmp):
+                    cropped_file_path = cropped_video_tmp
+                else:
+                    if os.path.exists(cropped_video_tmp): os.unlink(cropped_video_tmp)
+            except Exception as e:
+                print(f"⚠️ Erro ao cortar vídeo: {e}")
+
+        # 4. Upload do crop (Se houver) para reuso no Processamento
+        if cropped_file_path and os.path.exists(cropped_file_path):
+            try:
+                print(f"☁️ Enviando mídia cortada para recurve-save (reuso posterior)...")
+                is_vid = 'image' not in content_type
+                with open(cropped_file_path, 'rb') as cf:
+                    files = {'files': (f"crop_{'vid' if is_vid else 'img'}{ext}", cf, content_type)}
+                    data = {'long_duration': 'yes'} if is_vid else {}
+                    up_resp = requests.post("https://habulaj-recurve-save.hf.space/upload", files=files, data=data, timeout=120)
+                    up_resp.raise_for_status()
+                    crop_content_url = up_resp.json().get("url", "")
+                    print(f"✅ Crop content URL: {crop_content_url}")
+            except Exception as up_e:
+                print(f"⚠️ Erro ao subir crop para recurve-save: {up_e}")
+
+        # Ordem de anexos para Gemini: [cortado, original]
+        files_to_send = []
         if cropped_file_path and os.path.exists(cropped_file_path):
             files_to_send.append(cropped_file_path)
+        files_to_send.append(media_path_to_analyze)
 
         contexto_add = f"\n\nContexto Adicional / Legenda Original:\n{context_text}" if context_text else ""
 
@@ -1494,6 +1555,9 @@ async def run_filter_account(account: str):
             "image_needs_correction": filter_data.get("image_needs_correction", False),
             "contains_image": filter_data.get("contains_image", False)
         }
+        if crop_content_url:
+            patch_payload["crop_content_url"] = crop_content_url
+            
         res_patch = requests.patch(update_url, headers=headers, json=patch_payload, timeout=10)
         if not res_patch.ok:
             print(f"⚠️ Erro ao atualizar Supabase: {res_patch.text}")