Add application files

.dockerignore

@@ -0,0 +1,17 @@
+.git
+.gitignore
+.vscode
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+env/
+venv/
+ENV/
+*.log
+.DS_Store
+*.swp
+*.swo
+.ipynb_checkpoints
+.pytest_cache

Dockerfile

@@ -6,9 +6,14 @@ WORKDIR /app
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ffmpeg \
     build-essential \
+    git \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
+# Download NLTK data
+RUN python -m pip install --no-cache-dir nltk
+RUN python -c "import nltk; nltk.download('punkt'); nltk.download('wordnet')"
+
 # Copy requirements first for better caching
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
@@ -16,8 +21,8 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy the rest of the application
 COPY . .
 
-# Expose the port
-EXPOSE 5000
+# Port for Hugging Face Spaces
+EXPOSE 7860
 
-# Run using Gunicorn
-CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"] 
+# Run using Uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"] 

app.py

@@ -1,7 +1,15 @@
+from fastapi import FastAPI
+import uvicorn
 from app_fastapi import app
 
 # This file is used for Hugging Face Spaces deployment
 # Spaces will automatically detect this app.py file and serve the FastAPI app
 
 # For local development, you can run:
-# uvicorn app_fastapi:app --host 0.0.0.0 --port 8000 
+# uvicorn app_fastapi:app --host 0.0.0.0 --port 8000 
+
+# Hugging Face Spaces expects this variable to be named 'app'
+# Already imported from app_fastapi.py
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860) 

app_fastapi.py

@@ -1 +1,243 @@
- 
+from fastapi import FastAPI, Request, Response, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel
+import os
+import base64
+import numpy as np
+import torch
+import time
+from transformers import pipeline
+import threading
+import json
+import logging
+from topic_segmenter import TopicSegmenter
+import uvicorn
+from typing import Optional, Dict, Any, List
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI()
+logging.basicConfig(level=logging.INFO)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Templates for HTML rendering
+templates = Jinja2Templates(directory="templates")
+
+# Serve static files - mount this after creating the app but before routes
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Models cache
+models = {}
+model_lock = threading.Lock()
+
+# Route to serve the main page
+@app.get("/")
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+# Defining Pydantic models for request/response data
+class AudioRequest(BaseModel):
+    audio: str
+    model: Optional[str] = "openai/whisper-base"
+
+class TranscriptRequest(BaseModel):
+    transcript: str
+
+class ModelCheckRequest(BaseModel):
+    model: str
+
+def get_model(model_name):
+    """Load and cache the model"""
+    with model_lock:
+        if model_name not in models:
+            logging.info(f"Loading model: {model_name}")
+            
+            hf_model_name = model_name
+            if model_name.startswith('Xenova/'):
+                base_name = model_name.split('/')[-1] 
+                if '.en' in base_name:
+                    size = base_name.split('.')[0].replace('whisper-', '')
+                    hf_model_name = f"openai/whisper-{size}"
+                else:
+                    size = base_name.replace('whisper-', '')
+                    hf_model_name = f"openai/whisper-{size}"
+                
+                logging.info(f"Converting Xenova model {model_name} to {hf_model_name}")
+            
+            models[model_name] = pipeline(
+                "automatic-speech-recognition", 
+                hf_model_name,
+                chunk_length_s=30,
+                stride_length_s=5
+            )
+            logging.info(f"Model {model_name} loaded successfully")
+        return models[model_name]
+
+def process_audio(audio_data, sample_rate=16000, model_name="openai/whisper-base"):
+    """Process audio data with the Whisper model"""
+    try:
+        model = get_model(model_name)
+        
+        chunk_duration = 30
+        samples_per_chunk = chunk_duration * sample_rate
+        total_chunks = (len(audio_data) + samples_per_chunk - 1) // samples_per_chunk
+        
+        full_transcript = ""
+        
+        for i in range(total_chunks):
+            start = i * samples_per_chunk
+            end = min(start + samples_per_chunk, len(audio_data))
+            chunk = audio_data[start:end]
+            
+            logging.info(f"Processing chunk {i+1}/{total_chunks}")
+            
+            result = model(
+                chunk,
+                return_timestamps=True,
+                generate_kwargs={"language": "english", "task": "transcribe"}
+            )
+            
+            if "chunks" in result and len(result["chunks"]) > 0:
+                for chunk_with_time in result["chunks"]:
+                    if "timestamp" in chunk_with_time and len(chunk_with_time["timestamp"]) == 2:
+                        chunk_start_seconds = chunk_with_time["timestamp"][0]
+                        absolute_start_time = (start / sample_rate) + chunk_start_seconds
+                        timestamp = f"[{int(absolute_start_time)}]"
+                        full_transcript += f"{timestamp} {chunk_with_time['text'].strip()}\n"
+            else:
+                timestamp = f"[{int(start / sample_rate)}]"
+                full_transcript += f"{timestamp} {result['text'].strip()}\n"
+                
+        return full_transcript
+    except Exception as e:
+        logging.error(f"Error processing audio: {str(e)}")
+        raise
+
+@app.post("/transcribe")
+async def transcribe(request: AudioRequest):
+    try:
+        if not request.audio:
+            raise HTTPException(status_code=400, detail="No audio data provided")
+            
+        audio_bytes = base64.b64decode(request.audio)
+        audio_np = np.frombuffer(audio_bytes, dtype=np.float32)
+        
+        start_time = time.time()
+        transcript = process_audio(audio_np, model_name=request.model)
+        elapsed_time = time.time() - start_time
+        
+        logging.info(f"Transcription completed in {elapsed_time:.2f} seconds")
+        
+        return {"transcript": transcript}
+    except Exception as e:
+        logging.error(f"Transcription error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/analyze")
+async def analyze_topics(request: TranscriptRequest):
+    try:
+        if not request.transcript:
+            raise HTTPException(status_code=400, detail="No transcript provided")
+            
+        transcript = request.transcript
+        
+        segmenter = TopicSegmenter(
+            window_size=2,  
+            similarity_threshold=0.15,  
+            context_size=1,
+            min_segment_size=2,  
+            topic_similarity_threshold=0.25,  
+            max_topics=6,  
+            hierarchical_threshold=0.6  
+        )
+        
+        segments, topic_mappings, topic_history, topic_hierarchies = segmenter.segment_transcript(transcript)
+        
+        results = []
+        
+        parent_topics = set()
+        for parent_id in topic_hierarchies.keys():
+            parent_topics.add(parent_id)
+        
+        added_segments = set()
+        
+        for i, (segment, topic_id) in enumerate(zip(segments, topic_mappings)):
+            if i in added_segments:
+                continue
+                
+            if topic_id in parent_topics:
+                parent_data = {
+                    'segment_id': i,
+                    'topic_name': topic_history[topic_id][1],
+                    'content': segment,
+                    'timestamp': topic_history[topic_id][3],
+                    'is_parent': True,
+                    'children': []
+                }
+                
+                for j, (child_segment, child_topic_id) in enumerate(zip(segments, topic_mappings)):
+                    if j != i and child_topic_id in topic_hierarchies.get(topic_id, []):
+                        parent_data['children'].append({
+                            'segment_id': j,
+                            'topic_name': topic_history[child_topic_id][1],
+                            'content': child_segment,
+                            'timestamp': topic_history[child_topic_id][3]
+                        })
+                        added_segments.add(j)
+                
+                results.append(parent_data)
+                added_segments.add(i)
+            elif topic_id not in [child for children in topic_hierarchies.values() for child in children]:
+                results.append({
+                    'segment_id': i,
+                    'topic_name': topic_history[topic_id][1],
+                    'content': segment,
+                    'timestamp': topic_history[topic_id][3],
+                    'is_parent': False,
+                    'children': []
+                })
+                added_segments.add(i)
+        
+        return {"segments": results}
+    except Exception as e:
+        logging.error(f"Analysis error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/check_model")
+async def check_model(request: ModelCheckRequest):
+    try:
+        if not request.model:
+            raise HTTPException(status_code=400, detail="No model specified")
+            
+        model_name = request.model
+        logging.info(f"Checking model availability: {model_name}")
+        
+        if model_name in models:
+            logging.info(f"Model {model_name} is already loaded")
+            return {"available": True}
+            
+        supported_prefixes = [
+            "openai/whisper",
+            "Xenova/whisper",
+            "whisper"
+        ]
+        
+        available = any(model_name.startswith(prefix) or model_name.lower().startswith(prefix.lower()) for prefix in supported_prefixes)
+        
+        logging.info(f"Model {model_name} availability: {available}")
+        return {"available": available}
+    except Exception as e:
+        logging.error(f"Model check error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == '__main__':
+    uvicorn.run("app_fastapi:app", host="0.0.0.0", port=5000, reload=True) 

requirements.txt

@@ -1,5 +1,5 @@
-flask>=2.0.0
-gunicorn>=20.0.0
+fastapi>=0.68.0
+uvicorn>=0.15.0
 numpy>=1.19.0
 scikit-learn>=1.0.0
 nltk>=3.6.0
@@ -10,8 +10,6 @@ spacy>=3.0.0
 librosa>=0.8.0
 soundfile>=0.10.0
 thinc>=8.0.0
-fastapi>=0.68.0
-uvicorn>=0.15.0
 jinja2>=3.0.0
 python-multipart>=0.0.5
 pydantic>=1.8.2