ajustar para pt-br com helsinki

app.py

@@ -1,37 +1,88 @@
-from io import BytesIO
+import os
+import requests
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from dotenv import load_dotenv
 from PIL import Image
-import gradio as gr
-from transformers import BlipProcessor, BlipForConditionalGeneration
+from io import BytesIO
 
-# 1) Carrega processor e modelo BLIP
-processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
-model     = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+# Carrega variáveis de ambiente de .env (se existir)
+load_dotenv()
+HF_TOKEN = os.getenv('HF_API_TOKEN')
+if not HF_TOKEN:
+    raise RuntimeError("Defina HF_API_TOKEN no .env")
+
+# Endpoints do Hugging Face Inference API
+BLIP_API_URL = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base"
+TRANS_API_URL = "https://api-inference.huggingface.co/models/Helsinki-NLP/opus-mt-en-pt-br"
+HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+
+# Inicialização do Flask e CORS
+app = Flask(__name__)
+CORS(app)
+
+
+def infer_caption(image_bytes):
+    # Gerar legenda em inglês com BLIP
+    response_blip = requests.post(
+        BLIP_API_URL,
+        headers=HEADERS,
+        data=image_bytes,
+        timeout=60
+    )
+    if response_blip.status_code != 200:
+        raise RuntimeError(f"Erro BLIP: {response_blip.status_code} - {response_blip.text}")
+    blip_output = response_blip.json()
+    if isinstance(blip_output, list) and blip_output and 'generated_text' in blip_output[0]:
+        english_caption = blip_output[0]['generated_text']
+    else:
+        raise RuntimeError(f"Resposta inesperada BLIP: {blip_output}")
+
+    # Traduzir legenda para pt-BR
+    response_trans = requests.post(
+        TRANS_API_URL,
+        headers=HEADERS,
+        json={"inputs": english_caption},
+        timeout=60
+    )
+    if response_trans.status_code != 200:
+        raise RuntimeError(f"Erro Tradução: {response_trans.status_code} - {response_trans.text}")
+    trans_output = response_trans.json()
+    if isinstance(trans_output, list) and trans_output and 'translation_text' in trans_output[0]:
+        portuguese_caption = trans_output[0]['translation_text']
+    else:
+        raise RuntimeError(f"Resposta inesperada Tradução: {trans_output}")
+
+    return portuguese_caption
+
+
+@app.route('/', methods=['GET'])
+def index():
+    return jsonify({'message': 'API rodando!'})
+
+
+@app.route('/upload', methods=['POST'])
+def upload():
+    # Validação de arquivo enviado
+    if 'image' not in request.files:
+        return jsonify({'error': 'Nenhuma imagem enviada'}), 400
+    img_file = request.files['image']
+    if img_file.filename == '':
+        return jsonify({'error': 'Nome de arquivo inválido'}), 400
+
+    # Leitura dos bytes da imagem
+    img_bytes = img_file.read()
+
+    # Obter legenda em português
+    try:
+        caption = infer_caption(img_bytes)
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+    # Retorna a legenda em JSON
+    return jsonify({'caption': caption})
 
-from io import BytesIO
-from PIL import Image
 
-def infer_caption(image):
-    # 1) Redimensiona mantendo proporção para max 1024×1024
-    max_size = 1024
-    w, h = image.size
-    if max(w, h) > max_size:
-        ratio = max_size / max(w, h)
-        new_size = (int(w * ratio), int(h * ratio))
-        image = image.resize(new_size, Image.LANCZOS)
-
-    # 2) Continua o fluxo BLIP
-    inputs  = processor(image, return_tensors="pt").to(model.device)
-    outputs = model.generate(**inputs)
-    return processor.decode(outputs[0], skip_special_tokens=True)
-
-# 2) Cria interface Gradio
-interface = gr.Interface(
-    fn=infer_caption,
-    inputs=gr.Image(type="pil"),
-    outputs="text",
-    title="Ouvir Para Ver",
-    description="Envie uma imagem e receba a descrição."
-)
-
-if __name__ == "__main__":
-    interface.launch(server_name="0.0.0.0", share=False)
+if __name__ == '__main__':
+    port = int(os.getenv('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=True)