Upload 7 files

.dockerignore

@@ -0,0 +1,31 @@
+# 1. Segurança (O MAIS IMPORTANTE)
+.env
+.git
+.gitignore
+
+# 2. Lixo do Python (Compilados locais que quebram no Linux)
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+
+# 3. Ambiente Virtual (O erro mais comum)
+# Nunca envie sua pasta venv, o Docker cria o ambiente dele sozinho!
+venv/
+env/
+.venv/
+
+# 4. Configurações de IDE (VS Code, Pycharm)
+.vscode/
+.idea/
+
+# 5. Arquivos temporários gerados pelo seu código
+# Não precisamos das fotos de teste ou recortes no servidor
+teste/
+recortes/
+temp_envio.jpg
+*.jpg
+*.png
+
+# 6. Logs e pastas do YOLO (Ultralytics cria a pasta 'runs')
+runs/

Dockerfile

@@ -0,0 +1,27 @@
+# Usa uma imagem Python leve
+FROM python:3.10-slim
+
+# Define o diretório de trabalho
+WORKDIR /app
+
+# Instala dependências do sistema (necessário para OpenCV/EasyOCR)
+RUN apt-get update && apt-get install -y \
+  libgl1-mesa-glx \
+  libglib2.0-0 \
+  && rm -rf /var/lib/apt/lists/*
+
+# Copia os requisitos e instala
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copia o resto do código
+COPY . .
+
+# Cria a pasta de usuário (Hugging Face exige permissão especial)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+  PATH=/home/user/.local/bin:$PATH
+
+# Comando para rodar na porta 7860 (Padrão do Hugging Face)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

api.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI, UploadFile, File
+import shutil
+import os
+
+# AQUI ESTÁ O SEGREDO: Importamos sua função pronta!
+from inteligencia import analisar_imagem_agora 
+
+app = FastAPI()
+
+@app.post("/analisar")
+async def api_analisar(arquivo: UploadFile = File(...)):
+    # 1. Salva o arquivo que chegou via internet num temp
+    nome_temp = f"temp_{arquivo.filename}"
+    
+    with open(nome_temp, "wb") as buffer:
+        shutil.copyfileobj(arquivo.file, buffer)
+    
+    # 2. Chama a SUA inteligência que já estava pronta
+    # Ela vai fazer o OCR, chamar o Gemini e devolver o resultado
+    resultado = analisar_imagem_agora(nome_temp)
+    
+    # 3. Limpa a sujeira (apaga a imagem temp)
+    os.remove(nome_temp)
+    
+    # 4. Devolve o resultado para o cliente (main.py ou app)
+    return resultado

inteligencia.py

@@ -0,0 +1,69 @@
+import google.generativeai as genai
+import easyocr
+from dotenv import load_dotenv
+import os
+import cv2  # ADICIONE ESTA LINHA
+
+# --- CONFIGURAÇÕES (Carregam apenas uma vez) ---
+load_dotenv()
+chave_api = os.getenv("GOOGLE_API_KEY") # <--- RECOLOQUE SUA CHAVE AQUI
+genai.configure(api_key=chave_api)
+model = genai.GenerativeModel('gemini-2.5-flash') 
+
+print("Inicializando OCR e IA... (Isso acontece só uma vez)")
+# Mantenha gpu=False se não tiver CUDA configurado
+reader = easyocr.Reader(['pt', 'en'], gpu=False)
+
+def analisar_imagem_agora(caminho_imagem):
+    print(f"\n--- 🧠 INICIANDO ANÁLISE: {caminho_imagem} ---")
+
+    # 1. OCR (LEITURA) - FORMA MAIS SEGURA
+    try:
+        print("Executando OCR...")
+        # CORREÇÃO: Carregar e converter para escala de cinza
+        img = cv2.imread(caminho_imagem)
+        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)    
+
+        resultados_brutos = reader.readtext(img_gray)
+        
+        # Vamos extrair só o texto manualmente para não dar erro de desempacotamento
+        lista_textos = []
+        for item in resultados_brutos:
+            # O formato do item é: ( [caixa], "texto lido", confiança )
+            if len(item) >= 2:
+                texto = item[1] 
+                lista_textos.append(texto)
+        texto_detectado = " ".join(lista_textos)
+        print(f"📖 Texto Bruto: {texto_detectado}")
+
+        if len(texto_detectado) < 2:
+            print("⚠️ Pouco texto. A identificação pode falhar.")
+            return 
+
+    except Exception as e:
+        print(f"Erro no OCR: {e}")
+        return
+
+
+
+    # 2. IA (INTERPRETAÇÃO)
+    prompt = f"""
+    Analise este texto de rótulo de produto: "{texto_detectado}"
+    Identifique: Categoria | Marca | Detalhes.
+    Responda apenas nesse formato e não escreva textos longos. Se não souber, diga "Não identificado".
+    """
+
+    try:
+        response = model.generate_content(prompt)
+        print(f"🤖 RESPOSTA IA: {response.text}") # Isso aparece no servidor (OK)
+        
+        # --- O SEGREDO ESTÁ AQUI: TEM QUE TER O RETURN ---
+        return {
+            "texto_lido": texto_detectado,
+            "analise_ia": response.text
+        }
+        # -------------------------------------------------
+
+    except Exception as e:
+        print(f"Erro na IA: {e}")
+        return {"texto_lido": "Erro", "analise_ia": "Erro na IA"}

main.py

@@ -0,0 +1,129 @@
+import cv2
+from ultralytics import YOLO
+import os
+import time
+import requests # <--- ADICIONADO: Necessário para falar com a API
+
+# --- REMOVIDO: from inteligencia import ... 
+# Não importamos mais a inteligência aqui, pois ela roda no servidor (api.py)
+
+# Cria pastas para organizar
+os.makedirs('resultados/recortes', exist_ok=True)
+
+print("Carregando modelo YOLO (Visão)... aguarde.")
+model = YOLO('yolov8m.pt') 
+print('Modelo carregado com sucesso!')
+
+def read_image():
+    cap = cv2.VideoCapture(0)
+    cap.set(3, 1280)
+    cap.set(4, 720)
+
+    print('\n--- SISTEMA CLIENTE INICIADO ---')
+    print('📷 Aponte para o produto.')
+    print('📡 O processamento será feito pela API.')
+    print('🔘 Pressione "ESPAÇO" para enviar.')
+    print('❌ Pressione "q" para SAIR.\n')
+
+    while True:
+        success, frame = cap.read()
+        if not success:
+            print('Falha ao capturar imagem.')
+            break
+
+        # Faz a detecção
+        results = model.predict(frame, conf=0.5, verbose=False)
+
+        frame_anotado = frame.copy() 
+        recorte_atual = None
+
+        # Loop por cada detecção
+        for box in results[0].boxes:
+            classe_id = int(box.cls[0])
+            name = model.names[classe_id]
+            
+            # Filtro de pessoas
+            if name == 'person':
+                continue
+
+            confianca = float(box.conf[0])
+
+            if confianca > 0.6:
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                
+                # Desenha o retângulo
+                cv2.rectangle(frame_anotado, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                
+                texto = f"{name.upper()} {confianca:.2f}"
+                cv2.putText(frame_anotado, texto, (x1, y1 - 10), 
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+                
+                # Prepara o recorte com limites seguros
+                h, w, _ = frame.shape
+                x1, y1 = max(0, x1), max(0, y1)
+                x2, y2 = min(w, x2), min(h, y2)
+                
+                recorte_atual = frame[y1:y2, x1:x2]
+                
+                cv2.putText(frame_anotado, "PRODUTO DETECTADO! (Espaco para Enviar)", (50, 50), 
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+
+        cv2.imshow("Camera Cliente", frame_anotado)
+
+        key = cv2.waitKey(1)
+        if key == ord('q'):
+            break
+        elif key == 32: # ESPAÇO
+            if recorte_atual is not None:
+                # Salva temporariamente para envio
+                nome_arquivo = "temp_envio.jpg"
+                cv2.imwrite(nome_arquivo, recorte_atual)
+                
+                print("📡 Enviando imagem para a API...")                
+                
+                try:
+                    url = "http://127.0.0.1:8000/analisar"
+                    
+                    # CORREÇÃO DO ARQUIVO ABERTO:
+                    # Usamos 'with open' para garantir que o arquivo feche após o envio
+                    with open(nome_arquivo, 'rb') as f:
+                        arquivos = {'arquivo': f}
+                        resposta = requests.post(url, files=arquivos)
+                    
+                    # Agora o arquivo já está fechado, o código pode continuar
+                    
+                    if resposta.status_code == 200:
+                        dados = resposta.json()
+                        
+                        # Verifica se dados não veio vazio
+                        if dados: 
+                            print("\n" + "="*40)
+                            print(f"📖 Texto Lido: {dados.get('texto_lido')}")
+                            print(f"🤖 Análise IA: {dados.get('analise_ia')}")
+                            print("="*40 + "\n")
+                        else:
+                            print("⚠️ A API retornou dados vazios.")
+                    else:
+                        print(f"❌ Erro na API: {resposta.status_code}")
+                    
+                except Exception as e:
+                    print(f"❌ Erro: {e}")
+
+                # Agora sim pode deletar, pois o 'with open' já fechou o arquivo
+                if os.path.exists(nome_arquivo):
+                    try:
+                        os.remove(nome_arquivo)
+                    except:
+                        pass # Se não der pra deletar, tudo bem, ele sobrescreve na próxima
+            else:
+                print("⚠️ Nada detectado para enviar.")
+
+    cap.release()
+    cv2.destroyAllWindows()
+    # Limpa o arquivo temporário ao sair, se existir
+    if os.path.exists("temp_envio.jpg"):
+        os.remove("temp_envio.jpg")
+    print("Programa encerrado.")
+
+if __name__ == "__main__":
+    read_image()

yolov8m.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d4a90cdc7a21786cc59cd19778e9eafff836df9e2da32524737c7ee6efe4fe5
+size 52136884