Update app.py

app.py

@@ -1,192 +1,60 @@
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 from faster_whisper import WhisperModel
-import os
 import tempfile
-import logging
-from werkzeug.utils import secure_filename
-import traceback
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+import os
 
-# Initialize Flask app
 app = Flask(__name__)
-CORS(app)  # Enable CORS for cross-origin requests
-
-# Configuration
-app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB max file size
-app.config['ALLOWED_EXTENSIONS'] = {'wav', 'mp3', 'm4a', 'flac', 'ogg', 'webm'}
+CORS(app)
 
-# Load Whisper model
-MODEL_SIZE = os.getenv('WHISPER_MODEL', 'tiny')  # Can be overridden via env var
-DEVICE = 'cpu'
-COMPUTE_TYPE = 'int8'
+# Load model (same as your working Gradio code)
+model_size = "tiny"
+device = "cpu"
+compute_type = "int8"
+model = WhisperModel(model_size, device=device, compute_type=compute_type)
 
-logger.info(f"Loading Whisper model: {MODEL_SIZE}...")
-model = WhisperModel(MODEL_SIZE, device=DEVICE, compute_type=COMPUTE_TYPE)
-logger.info("Model loaded successfully!")
-
-def allowed_file(filename):
-    """Check if file has an allowed extension"""
-    return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
-
-def transcribe_audio(audio_path):
-    """Transcribe audio file and return text"""
-    try:
-        segments, info = model.transcribe(audio_path, beam_size=5, language=None)
-        
-        # Collect all segments
-        transcription = []
-        for segment in segments:
-            transcription.append(segment.text)
-        
-        return {
-            'success': True,
-            'text': ' '.join(transcription),
-            'language': str(info.language),
-            'duration': info.duration
-        }
-    except Exception as e:
-        logger.error(f"Transcription error: {str(e)}")
-        return {
-            'success': False,
-            'error': str(e)
-        }
+def transcribe(audio_path):
+    """Same transcription logic that works in your Gradio app"""
+    if audio_path is None:
+        return None
+    segments, _ = model.transcribe(audio_path, beam_size=5)
+    return "".join([segment.text for segment in segments])
 
 @app.route('/health', methods=['GET'])
-def health_check():
-    """Health check endpoint"""
-    return jsonify({
-        'status': 'healthy',
-        'model': MODEL_SIZE,
-        'device': DEVICE
-    })
+def health():
+    return jsonify({"status": "healthy", "model": model_size})
 
 @app.route('/transcribe', methods=['POST'])
-def transcribe():
-    """
-    Transcribe audio file
-    Expected: multipart/form-data with 'audio' file field
-    Optional: 'language' form field (ISO code, e.g., 'en', 'fr')
-    """
-    # Check if file is present
+def transcribe_audio():
+    # Check if audio file was uploaded
     if 'audio' not in request.files:
-        return jsonify({'error': 'No audio file provided'}), 400
+        return jsonify({"error": "No audio file provided"}), 400
     
     file = request.files['audio']
-    
-    # Check if filename is empty
     if file.filename == '':
-        return jsonify({'error': 'No file selected'}), 400
+        return jsonify({"error": "No file selected"}), 400
     
-    # Check file type
-    if not allowed_file(file.filename):
-        return jsonify({'error': f'File type not allowed. Allowed: {", ".join(app.config["ALLOWED_EXTENSIONS"])}'}), 400
+    # Save uploaded file temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
+        file.save(tmp_file.name)
+        tmp_path = tmp_file.name
     
-    # Save file temporarily
-    temp_file = None
     try:
-        # Create temporary file
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f".{file.filename.rsplit('.', 1)[1].lower()}")
-        file.save(temp_file.name)
-        
-        # Get optional language parameter
-        language = request.form.get('language', None)
-        
-        # Transcribe
-        logger.info(f"Transcribing file: {file.filename}")
-        result = transcribe_audio(temp_file.name)
-        
-        if result['success']:
-            return jsonify({
-                'success': True,
-                'transcription': result['text'],
-                'language': result['language'],
-                'duration': result['duration'],
-                'filename': secure_filename(file.filename)
-            })
-        else:
-            return jsonify({'error': result['error']}), 500
-            
+        # Transcribe using your working function
+        text = transcribe(tmp_path)
+        if text is None:
+            return jsonify({"error": "No audio detected"}), 400
+        
+        return jsonify({
+            "success": True,
+            "transcription": text
+        })
     except Exception as e:
-        logger.error(f"Error processing request: {traceback.format_exc()}")
-        return jsonify({'error': str(e)}), 500
-    
+        return jsonify({"error": str(e)}), 500
     finally:
-        # Clean up temporary file
-        if temp_file and os.path.exists(temp_file.name):
-            os.unlink(temp_file.name)
-
-@app.route('/transcribe_url', methods=['POST'])
-def transcribe_url():
-    """
-    Transcribe audio from URL
-    Expected JSON: {'url': 'https://example.com/audio.mp3', 'language': 'en'}
-    """
-    data = request.get_json()
-    
-    if not data or 'url' not in data:
-        return jsonify({'error': 'No URL provided'}), 400
-    
-    audio_url = data['url']
-    language = data.get('language', None)
-    
-    import requests
-    import urllib.parse
-    
-    # Download audio from URL
-    temp_file = None
-    try:
-        # Download file
-        response = requests.get(audio_url, stream=True, timeout=30)
-        response.raise_for_status()
-        
-        # Get filename from URL or content-disposition
-        filename = urllib.parse.unquote(audio_url.split('/')[-1])
-        if '.' not in filename:
-            filename = 'audio.mp3'  # Default extension
-        
-        # Create temporary file
-        extension = filename.rsplit('.', 1)[1].lower() if '.' in filename else 'mp3'
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f".{extension}")
-        
-        # Save downloaded content
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                temp_file.write(chunk)
-        temp_file.close()
-        
-        # Transcribe
-        logger.info(f"Transcribing from URL: {audio_url}")
-        result = transcribe_audio(temp_file.name)
-        
-        if result['success']:
-            return jsonify({
-                'success': True,
-                'transcription': result['text'],
-                'language': result['language'],
-                'duration': result['duration'],
-                'source_url': audio_url
-            })
-        else:
-            return jsonify({'error': result['error']}), 500
-            
-    except requests.exceptions.RequestException as e:
-        return jsonify({'error': f'Failed to download audio: {str(e)}'}), 400
-    except Exception as e:
-        logger.error(f"Error processing URL: {traceback.format_exc()}")
-        return jsonify({'error': str(e)}), 500
-    finally:
-        if temp_file and os.path.exists(temp_file.name):
-            os.unlink(temp_file.name)
-
-@app.errorhandler(413)
-def too_large(e):
-    return jsonify({'error': 'File too large. Maximum size is 50MB'}), 413
+        # Clean up temp file
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
 
 if __name__ == '__main__':
-    port = int(os.getenv('PORT', 5000))
-    app.run(host='0.0.0.0', port=port, debug=False)
+    app.run(host='0.0.0.0', port=5000, debug=False)