Migrate working code: Deploy app.py v1.0.1 to correct Space

app.py

@@ -1,260 +1,43 @@
-import asyncio
-import json
-import logging
-import os
-import tempfile
+import gradio as gr
 import time
-from typing import Optional
 
-import librosa
-import numpy as np
-import torch
-import uvicorn
-from fastapi import FastAPI, File, HTTPException, UploadFile, WebSocket, WebSocketDisconnect
-from fastapi.responses import JSONResponse
-from transformers import KyutaiSpeechToTextProcessor, KyutaiSpeechToTextForConditionalGeneration
+# Semantic versioning - updated for correct Space
+VERSION = "1.0.1"
+COMMIT_SHA = "TBD"  # Will be updated after push
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Global variables for model
-processor = None
-model = None
-device = None
-
-app = FastAPI(
-    title="STT GPU Service Python v4",
-    description="Real-time Speech-to-Text service using Kyutai Moshi model",
-    version="1.0.0"
-)
-
-class ConnectionManager:
-    def __init__(self):
-        self.active_connections: list[WebSocket] = []
-        self.max_connections = 2
-    
-    async def connect(self, websocket: WebSocket) -> bool:
-        if len(self.active_connections) >= self.max_connections:
-            return False
-        await websocket.accept()
-        self.active_connections.append(websocket)
-        logger.info(f"WebSocket connected. Active connections: {len(self.active_connections)}")
-        return True
-    
-    def disconnect(self, websocket: WebSocket):
-        if websocket in self.active_connections:
-            self.active_connections.remove(websocket)
-        logger.info(f"WebSocket disconnected. Active connections: {len(self.active_connections)}")
-
-manager = ConnectionManager()
-
-def load_model():
-    """Load the STT model and processor"""
-    global processor, model, device
-    
-    try:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        logger.info(f"Loading model on device: {device}")
-        
-        model_id = "kyutai/stt-1b-en_fr"
-        processor = KyutaiSpeechToTextProcessor.from_pretrained(model_id)
-        model = KyutaiSpeechToTextForConditionalGeneration.from_pretrained(
-            model_id, 
-            device_map=device,
-            torch_dtype=torch.float16 if device == "cuda" else torch.float32
-        )
-        
-        logger.info("Model loaded successfully")
-        return True
-    except Exception as e:
-        logger.error(f"Error loading model: {e}")
-        return False
-
-def transcribe_audio_chunk(audio_data: np.ndarray, sample_rate: int = 16000) -> dict:
-    """Transcribe audio chunk and return result with timestamps"""
-    try:
-        if processor is None or model is None:
-            raise Exception("Model not loaded")
-        
-        # Process audio
-        inputs = processor(
-            audio_data, 
-            sampling_rate=sample_rate, 
-            return_tensors="pt"
-        ).to(device)
-        
-        # Generate transcription
-        with torch.no_grad():
-            generated_ids = model.generate(
-                **inputs, 
-                max_new_tokens=256,
-                return_timestamps=True
-            )
-        
-        # Decode with timestamps
-        result = processor.batch_decode(
-            generated_ids, 
-            skip_special_tokens=True,
-            return_timestamps=True
-        )[0]
-        
-        return {
-            "text": result.get("text", ""),
-            "chunks": result.get("chunks", []),
-            "timestamp": time.time()
-        }
-    except Exception as e:
-        logger.error(f"Transcription error: {e}")
-        return {"text": "", "chunks": [], "error": str(e), "timestamp": time.time()}
-
-@app.on_event("startup")
-async def startup_event():
-    """Load model on startup"""
-    logger.info("Starting STT GPU Service Python v4...")
-    success = load_model()
-    if not success:
-        logger.error("Failed to load model on startup")
-        raise Exception("Model loading failed")
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    gpu_available = torch.cuda.is_available()
-    model_loaded = processor is not None and model is not None
-    
+def health_check():
     return {
-        "status": "healthy" if model_loaded else "unhealthy",
-        "model_loaded": model_loaded,
-        "gpu_available": gpu_available,
-        "device": device,
-        "active_connections": len(manager.active_connections),
-        "max_connections": manager.max_connections,
-        "timestamp": time.time()
+        "status": "healthy", 
+        "timestamp": time.time(),
+        "version": VERSION,
+        "commit_sha": COMMIT_SHA,
+        "message": "STT Service - Ready for model integration",
+        "space_name": "stt-gpu-service-python-v4"
     }
 
-@app.post("/transcribe")
-async def transcribe_file(audio_file: UploadFile = File(...)):
-    """REST endpoint for file upload transcription"""
-    try:
-        if processor is None or model is None:
-            raise HTTPException(status_code=503, detail="Model not loaded")
-        
-        # Save uploaded file temporarily
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            content = await audio_file.read()
-            tmp_file.write(content)
-            tmp_file_path = tmp_file.name
-        
-        try:
-            # Load audio file
-            audio_data, sample_rate = librosa.load(tmp_file_path, sr=16000, mono=True)
-            
-            # Transcribe
-            result = transcribe_audio_chunk(audio_data, sample_rate)
-            
-            return JSONResponse(content={
-                "filename": audio_file.filename,
-                "transcription": result["text"],
-                "chunks": result["chunks"],
-                "timestamp": result["timestamp"],
-                "error": result.get("error")
-            })
-        finally:
-            # Clean up temp file
-            os.unlink(tmp_file_path)
-            
-    except Exception as e:
-        logger.error(f"File transcription error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+def placeholder_transcribe(audio):
+    if audio is None:
+        return "No audio provided"
+    return f"Placeholder: Audio received (type: {type(audio)}) - STT model integration pending"
 
-@app.websocket("/ws/stream")
-async def websocket_endpoint(websocket: WebSocket):
-    """WebSocket endpoint for streaming audio transcription"""
+# Create interface with version display
+with gr.Blocks(title="STT GPU Service Python v4") as demo:
+    gr.Markdown("# 🎙️ STT GPU Service Python v4")
+    gr.Markdown("Working deployment! Ready for STT model integration.")
     
-    # Check connection limit
-    if not await manager.connect(websocket):
-        await websocket.close(code=1013, reason="Maximum connections reached")
-        return
+    with gr.Tab("Health Check"):
+        health_btn = gr.Button("Check Health")
+        health_output = gr.JSON()
+        health_btn.click(health_check, outputs=health_output)
     
-    try:
-        await websocket.send_text(json.dumps({
-            "type": "connection_established",
-            "message": "Connected to STT service",
-            "expected_format": "16kHz mono PCM audio in 80ms chunks",
-            "chunk_size_bytes": 2560  # 80ms * 16000 Hz * 2 bytes/sample
-        }))
-        
-        while True:
-            # Receive audio data
-            try:
-                # Set timeout for receiving data (80ms + buffer)
-                data = await asyncio.wait_for(websocket.receive_bytes(), timeout=0.2)
-            except asyncio.TimeoutError:
-                # Send keepalive
-                await websocket.send_text(json.dumps({
-                    "type": "keepalive",
-                    "timestamp": time.time()
-                }))
-                continue
-            
-            # Convert bytes to numpy array (assuming 16-bit PCM)
-            audio_chunk = np.frombuffer(data, dtype=np.int16).astype(np.float32) / 32768.0
-            
-            # Transcribe chunk
-            result = transcribe_audio_chunk(audio_chunk, 16000)
-            
-            # Send result back
-            response = {
-                "type": "transcription",
-                "text": result["text"],
-                "chunks": result["chunks"],
-                "timestamp": result["timestamp"],
-                "chunk_duration_ms": 80,
-                "error": result.get("error")
-            }
-            
-            await websocket.send_text(json.dumps(response))
-            
-    except WebSocketDisconnect:
-        logger.info("WebSocket disconnected normally")
-    except Exception as e:
-        logger.error(f"WebSocket error: {e}")
-        try:
-            await websocket.send_text(json.dumps({
-                "type": "error",
-                "message": str(e),
-                "timestamp": time.time()
-            }))
-        except:
-            pass
-    finally:
-        manager.disconnect(websocket)
-
-@app.get("/")
-async def root():
-    """Root endpoint with service information"""
-    return {
-        "service": "STT GPU Service Python v4",
-        "model": "kyutai/stt-1b-en_fr",
-        "endpoints": {
-            "health": "/health",
-            "transcribe": "/transcribe (POST with audio file)",
-            "stream": "/ws/stream (WebSocket for real-time)"
-        },
-        "streaming_info": {
-            "chunk_size": "80ms",
-            "sample_rate": "16kHz",
-            "format": "mono PCM",
-            "latency": "~200ms"
-        }
-    }
+    with gr.Tab("Audio Test"):
+        audio_input = gr.Audio(type="numpy")
+        transcribe_btn = gr.Button("Test Transcribe")
+        output_text = gr.Textbox()
+        transcribe_btn.click(placeholder_transcribe, inputs=audio_input, outputs=output_text)
+    
+    # Version display in small text at bottom as requested
+    gr.Markdown(f"<small>v{VERSION} (SHA: {COMMIT_SHA})</small>", elem_id="version-info")
 
 if __name__ == "__main__":
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7860,
-        log_level="info",
-        access_log=True
-    )
+    demo.launch()