go

app.py

@@ -1,42 +1,182 @@
-from fastapi import FastAPI, HTTPException
+import os
+import joblib
+import numpy as np
+import torch
+import torchaudio
+import yt_dlp
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
-from working import main
+from pydantic import BaseModel, HttpUrl
+from typing import Optional, Union
+import logging
+
+# --- 0. CONFIGURAÇÃO DE LOGGING ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # --- 1. SETUP DO FASTAPI ---
 app = FastAPI(
     title="Audio Classifier API",
-    description="Uma API para classificar áudios como 'REAL' ou 'IA'."
+    description="Uma API para classificar áudios como 'REAL' ou 'IA', aceitando uploads de arquivo ou URLs."
 )
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], 
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# Monta o diretório estático para servir o index.html e outros arquivos.
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
-# --- 2. MODELO DE DADOS ---
-class URLPayload(BaseModel):
-    url: str
+# --- 2. CARREGAMENTO DO MODELO ---
+try:
+    modelo_path = 'modelo_random_forest.joblib'
+    scaler_path = 'scaler.joblib'
+    if not os.path.exists(modelo_path) or not os.path.exists(scaler_path):
+        raise FileNotFoundError("Arquivos do modelo ou scaler não encontrados.")
+    model = joblib.load(modelo_path)
+    scaler = joblib.load(scaler_path)
+    logger.info("Modelo e scaler carregados com sucesso.")
+except Exception as e:
+    logger.error(f"Erro ao carregar o modelo ou scaler: {e}")
+    # Encerra o aplicativo se os modelos não puderem ser carregados.
+    raise RuntimeError(f"Não foi possível carregar os artefatos do modelo: {e}") from e
+
+# --- 3. FUNÇÕES DE PROCESSAMENTO DE ÁUDIO ---
+def extract_features(waveform, sample_rate, n_mfcc=13):
+    """Extrai MFCCs de um waveform."""
+    mfcc_transform = torchaudio.transforms.MFCC(
+        sample_rate=sample_rate,
+        n_mfcc=n_mfcc,
+        melkwargs={'n_fft': 400, 'hop_length': 160, 'n_mels': 23, 'center': False}
+    )
+    mfcc = mfcc_transform(waveform)
+    return np.mean(mfcc.squeeze(0).numpy(), axis=1)
+
+def process_audio_file(file_path: str):
+    """
+    Carrega um arquivo de áudio, extrai features e as escala.
+    Retorna None se o áudio for muito curto ou inválido.
+    """
+    try:
+        waveform, sample_rate = torchaudio.load(file_path)
+        
+        # Garante que o áudio tenha pelo menos uma duração mínima
+        min_duration_samples = sample_rate * 1  # 1 segundo
+        if waveform.shape[1] < min_duration_samples:
+            logger.warning(f"Áudio {file_path} é muito curto para análise.")
+            return None
+
+        # Garante a monocanalidade somando os canais, se houver mais de um.
+        if waveform.shape[0] > 1:
+            waveform = torch.mean(waveform, dim=0, keepdim=True)
 
-# --- 3. ROTA DE CLASSIFICAÇÃO ---
+        features = extract_features(waveform, sample_rate)
+        scaled_features = scaler.transform([features])
+        return scaled_features
+    except Exception as e:
+        logger.error(f"Erro ao processar o arquivo de áudio {file_path}: {e}")
+        raise ValueError(f"Não foi possível processar o arquivo de áudio: {e}")
+
+def download_audio_from_url(url: str, output_path: str = "temp_audio"):
+    """
+    Baixa áudio de uma URL (YouTube, Twitter, etc.) usando yt-dlp.
+    Salva como .wav.
+    """
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'wav',
+            'preferredquality': '192',
+        }],
+        'outtmpl': os.path.join(output_path, '%(id)s.%(ext)s'),
+        'quiet': True,
+    }
+    
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+            filename = ydl.prepare_filename(info).replace(info['ext'], 'wav')
+            
+            # Verifica se o arquivo foi realmente criado
+            if os.path.exists(filename):
+                return filename
+            else:
+                # Tenta encontrar o arquivo com base no ID do vídeo
+                base_filename = os.path.join(output_path, f"{info['id']}.wav")
+                if os.path.exists(base_filename):
+                    return base_filename
+                raise FileNotFoundError(f"Arquivo de áudio baixado não encontrado para a URL: {url}")
+    except Exception as e:
+        logger.error(f"Falha no download do áudio da URL {url}: {e}")
+        raise ConnectionError(f"Não foi possível baixar ou converter o áudio da URL fornecida. A URL é válida?")
+
+
+# --- 4. ROTA DE CLASSIFICAÇÃO ---
 @app.post("/api/classify")
-def classify_audio(payload: URLPayload):
+async def classify_audio(url: Optional[str] = Form(None), file: Optional[UploadFile] = File(None)):
+    temp_file_path = None
     try:
-        result = main(payload.url)
-        if "error" in result:
-            raise HTTPException(status_code=500, detail=result["error"])
-        return result
+        if file:
+            # Lógica para upload de arquivo
+            temp_dir = "temp_uploads"
+            if not os.path.exists(temp_dir):
+                os.makedirs(temp_dir)
+            
+            temp_file_path = os.path.join(temp_dir, file.filename)
+            with open(temp_file_path, "wb") as buffer:
+                buffer.write(await file.read())
+            
+            logger.info(f"Arquivo '{file.filename}' recebido.")
+            audio_path = temp_file_path
+
+        elif url:
+            # Lógica para download de URL
+            logger.info(f"Recebida URL para classificação: {url}")
+            audio_path = download_audio_from_url(url)
+            temp_file_path = audio_path # Marcar para exclusão posterior
+        
+        else:
+            raise HTTPException(status_code=400, detail="Nenhum arquivo ou URL fornecido.")
+
+        # Processamento e classificação do áudio
+        scaled_features = process_audio_file(audio_path)
+        if scaled_features is None:
+            raise HTTPException(status_code=400, detail="O áudio é muito curto ou não pôde ser processado.")
+
+        prediction = model.predict(scaled_features)
+        probability = model.predict_proba(scaled_features)
+        
+        label = prediction[0]
+        prob = probability[0][1] if label == 'IA' else probability[0][0]
+
+        return {"label": label, "probability": float(prob)}
+
+    except (ValueError, ConnectionError, FileNotFoundError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erro interno: {e}")
+        logger.error(f"Erro inesperado durante a classificação: {e}")
+        raise HTTPException(status_code=500, detail=f"Erro interno do servidor: {e}")
+    finally:
+        # Limpeza do arquivo temporário
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+            logger.info(f"Arquivo temporário '{temp_file_path}' removido.")
 
-# --- 4. ROTA DE SAÚDE ---
+
+# --- 5. ROTA DE SAÚDE ---
 @app.get("/", response_class=FileResponse)
 def home():
-    return "./static/index.html"
+    """Serve a página inicial da aplicação."""
+    return "./static/index.html"
+
+# Para executar localmente: uvicorn app:app --reload --port 8000

static/index.html

@@ -28,14 +28,14 @@
         }
         p {
             color: #666;
-            margin-bottom: 2rem;
+            margin-bottom: 1.5rem;
         }
         form {
             display: flex;
             flex-direction: column;
-            gap: 1rem;
+            gap: 1.5rem; /* Aumentado o espaço */
         }
-        input {
+        input[type="text"], input[type="file"] {
             padding: 0.75rem;
             border: 1px solid #ccc;
             border-radius: 4px;
@@ -61,40 +61,99 @@
             border-radius: 4px;
             background-color: #eaf5ff;
             min-height: 50px;
+            word-wrap: break-word;
+        }
+        .input-options {
+            display: flex;
+            justify-content: center;
+            gap: 1rem;
+            margin-bottom: 1rem;
         }
     </style>
 </head>
 <body>
     <div class="container">
         <h1>AI or Real Audio?</h1>
-        <p>Enter the URL of a video containing speech to detect deepfakes or narrative insertions. The program operates by analyzing the video's audio, which will be classified as "Real" or "AI".</p>
+        <p>Select an input method: upload an audio/video file (MP3, MP4, WAV) or provide a URL from a platform like YouTube or Twitter.</p>
+        
+        <div class="input-options">
+            <label>
+                <input type="radio" name="inputType" value="url" checked> URL
+            </label>
+            <label>
+                <input type="radio" name="inputType" value="file"> File Upload
+            </label>
+        </div>
+
         <form id="classifyForm">
-            <input type="text" id="videoUrl" placeholder="Example: https://video.twimg.com/..." required>
+            <div id="urlInputContainer">
+                <input type="text" id="url" placeholder="Example: https://www.youtube.com/watch?v=...">
+            </div>
+            <div id="fileInputContainer" style="display: none;">
+                <input type="file" id="file" accept=".mp3,.mp4,.wav,.m4a">
+            </div>
             <button type="submit">Classify</button>
         </form>
+        
         <div id="result" class="result-box">
-            Waiting for URL...
+            Waiting for input...
         </div>
     </div>
 
     <script>
         const form = document.getElementById('classifyForm');
-        const videoUrlInput = document.getElementById('videoUrl');
+        const urlInput = document.getElementById('url');
+        const fileInput = document.getElementById('file');
         const resultBox = document.getElementById('result');
+        
+        const urlInputContainer = document.getElementById('urlInputContainer');
+        const fileInputContainer = document.getElementById('fileInputContainer');
+
+        const inputTypeRadios = document.querySelectorAll('input[name="inputType"]');
+
+        inputTypeRadios.forEach(radio => {
+            radio.addEventListener('change', (e) => {
+                if (e.target.value === 'url') {
+                    urlInputContainer.style.display = 'block';
+                    fileInputContainer.style.display = 'none';
+                } else {
+                    urlInputContainer.style.display = 'none';
+                    fileInputContainer.style.display = 'block';
+                }
+            });
+        });
 
         form.addEventListener('submit', async (e) => {
             e.preventDefault();
-            const url = videoUrlInput.value;
+            
+            const selectedInputType = document.querySelector('input[name="inputType"]:checked').value;
+            const formData = new FormData();
+
+            if (selectedInputType === 'url') {
+                const url = urlInput.value;
+                if (!url) {
+                    resultBox.textContent = 'Please, provide an URL.';
+                    resultBox.style.color = 'red';
+                    return;
+                }
+                formData.append('url', url);
+            } else {
+                const file = fileInput.files[0];
+                if (!file) {
+                    resultBox.textContent = 'Please, select a file.';
+                    resultBox.style.color = 'red';
+                    return;
+                }
+                formData.append('file', file);
+            }
+
             resultBox.textContent = "Classifying...";
             resultBox.style.color = '#007bff';
 
             try {
                 const response = await fetch('/api/classify', {
                     method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({ url: url }),
+                    body: formData, // FormData é enviado sem o header 'Content-Type'
                 });
 
                 const data = await response.json();
@@ -103,11 +162,11 @@
                     resultBox.textContent = `Result: ${data.label} (Probability: ${(data.probability * 100).toFixed(2)}%)`;
                     resultBox.style.color = 'green';
                 } else {
-                    resultBox.textContent = `Erro: ${data.detail || 'Not possible to classify audio.'}`;
+                    resultBox.textContent = `Error: ${data.detail || 'Not possible to classify audio.'}`;
                     resultBox.style.color = 'red';
                 }
             } catch (error) {
-                resultBox.textContent = `Erro de conexão: ${error.message}`;
+                resultBox.textContent = `Conection error: ${error.message}`;
                 resultBox.style.color = 'red';
             }
         });