Add configuration and background task with polling

abhi logic implement nahi hua hai bas routes bana diye hai jo background mei jo karenge

.env.example

@@ -0,0 +1,18 @@
+# Audio Sentiment Analysis Configuration
+
+# Model Selection (choose one):
+# Option 1: superb/wav2vec2-base-superb-er (lightweight, 4 emotions)
+# Option 2: ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition (heavy, 7 emotions)
+MODEL_NAME=superb/wav2vec2-base-superb-er
+
+# Audio Processing Settings
+CHUNK_DURATION=3
+SAMPLE_RATE=16000
+
+# Supported Emotions (comma separated)
+EMOTIONS=Happy,Sad,Angry,Neutral
+
+# Flask API Settings
+FLASK_HOST=0.0.0.0
+FLASK_PORT=5000
+FLASK_DEBUG=True

.gitignore

@@ -4,3 +4,11 @@
 __pycache__/
 *.pyc
 uv.lock
+
+# Uploads folder (user uploaded files)
+uploads/
+
+# Temporary files
+tmp_rovodev_*
+*.tmp
+*.log

config.py

@@ -0,0 +1,48 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+class Config:
+    """Application configuration loaded from environment variables"""
+    
+    # Model Settings
+    MODEL_NAME = os.getenv('MODEL_NAME', 'superb/wav2vec2-base-superb-er')
+    
+    # Audio Processing Settings
+    CHUNK_DURATION = int(os.getenv('CHUNK_DURATION', 3))  # seconds
+    SAMPLE_RATE = int(os.getenv('SAMPLE_RATE', 16000))  # Hz
+    
+    # Emotions
+    EMOTIONS = os.getenv('EMOTIONS', 'Happy,Sad,Angry,Neutral').split(',')
+    
+    # Flask API Settings
+    FLASK_HOST = os.getenv('FLASK_HOST', '0.0.0.0')
+    FLASK_PORT = int(os.getenv('FLASK_PORT', 5000))
+    FLASK_DEBUG = os.getenv('FLASK_DEBUG', 'True').lower() == 'true'
+    
+    # Emotion Emoji Mapping
+    EMOTION_EMOJI_MAP = {
+        'Happy': '😊',
+        'Sad': '😢',
+        'Angry': '😡',
+        'Neutral': '😐',
+        'Fear': '😨',
+        'Surprise': '😲',
+        'Disgust': '🤢'
+    }
+    
+    # Emotion Color Mapping (for charts)
+    EMOTION_COLOR_MAP = {
+        'Happy': '#FFD700',
+        'Sad': '#4169E1',
+        'Angry': '#DC143C',
+        'Neutral': '#808080',
+        'Fear': '#9370DB',
+        'Surprise': '#FF8C00',
+        'Disgust': '#32CD32'
+    }
+
+# Create a config instance
+config = Config()

flask_app.py

@@ -1,13 +1,197 @@
-from flask import Flask, jsonify
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import uuid
+import os
+from datetime import datetime
+from config import config
+from concurrent.futures import ThreadPoolExecutor
+import threading
 
 app = Flask(__name__)
+CORS(app)  # Enable CORS for Streamlit
 
-@app.route('/helloworld', methods=['GET'])
-def hello_world():
+# Thread pool for background processing
+executor = ThreadPoolExecutor(max_workers=4)
+
+# In-memory storage for job status
+jobs = {}
+jobs_lock = threading.Lock()
+
+# Upload folder for temporary audio files
+UPLOAD_FOLDER = 'uploads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB max file size
+
+# Allowed audio extensions
+ALLOWED_EXTENSIONS = {'wav', 'mp3', 'ogg', 'flac', 'm4a'}
+
+def allowed_file(filename):
+    """Check if file extension is allowed"""
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "model": config.MODEL_NAME,
+        "version": "1.0.0"
+    })
+
+@app.route('/config', methods=['GET'])
+def get_config():
+    """Get current configuration"""
     return jsonify({
-        "message": "Hello World!",
-        "status": "success"
+        "model_name": config.MODEL_NAME,
+        "chunk_duration": config.CHUNK_DURATION,
+        "sample_rate": config.SAMPLE_RATE,
+        "emotions": config.EMOTIONS
     })
 
+@app.route('/upload', methods=['POST'])
+def upload_audio():
+    """
+    Upload audio file and start processing
+    Returns job_id for tracking progress
+    """
+    # Check if file is present in request
+    if 'file' not in request.files:
+        return jsonify({"error": "No file provided"}), 400
+    
+    file = request.files['file']
+    
+    # Check if file is selected
+    if file.filename == '':
+        return jsonify({"error": "No file selected"}), 400
+    
+    # Check if file type is allowed
+    if not allowed_file(file.filename):
+        return jsonify({
+            "error": f"Invalid file type. Allowed: {', '.join(ALLOWED_EXTENSIONS)}"
+        }), 400
+    
+    # Generate unique job ID
+    job_id = str(uuid.uuid4())
+    
+    # Save file
+    filename = f"{job_id}_{file.filename}"
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+    file.save(filepath)
+    
+    # Initialize job status
+    with jobs_lock:
+        jobs[job_id] = {
+            "status": "queued",
+            "progress": 0,
+            "message": "Audio file uploaded, waiting to process...",
+            "filename": file.filename,
+            "filepath": filepath,
+            "created_at": datetime.now().isoformat()
+        }
+    
+    # Submit background processing task
+    executor.submit(process_audio, job_id, filepath)
+    
+    return jsonify({
+        "job_id": job_id,
+        "message": "File uploaded successfully, processing started"
+    }), 202
+
+@app.route('/status/<job_id>', methods=['GET'])
+def get_status(job_id):
+    """
+    Get processing status for a job
+    Returns progress and results when complete
+    """
+    if job_id not in jobs:
+        return jsonify({"error": "Job not found"}), 404
+    
+    job = jobs[job_id]
+    
+    response = {
+        "job_id": job_id,
+        "status": job["status"],
+        "progress": job["progress"],
+        "message": job["message"]
+    }
+    
+    # If completed, include results
+    if job["status"] == "completed":
+        response["results"] = job.get("results", {})
+    
+    # If failed, include error
+    if job["status"] == "failed":
+        response["error"] = job.get("error", "Unknown error")
+    
+    return jsonify(response)
+
+def process_audio(job_id, filepath):
+    """
+    Process audio file and extract emotions
+    This runs in a background thread
+    """
+    import time  # For simulating processing time
+    
+    try:
+        # Update status to processing
+        with jobs_lock:
+            jobs[job_id]["status"] = "processing"
+            jobs[job_id]["progress"] = 10
+            jobs[job_id]["message"] = "Loading audio file..."
+        
+        # Simulate some processing time
+        time.sleep(1)
+        
+        with jobs_lock:
+            jobs[job_id]["progress"] = 30
+            jobs[job_id]["message"] = "Analyzing audio segments..."
+        
+        # TODO: Actual audio processing logic will go here
+        # For now, return mock data
+        time.sleep(2)
+        
+        with jobs_lock:
+            jobs[job_id]["progress"] = 70
+            jobs[job_id]["message"] = "Extracting emotions..."
+        
+        time.sleep(1)
+        
+        # Mock results
+        results = {
+            "duration": "00:45",
+            "total_chunks": 15,
+            "emotions_detected": 4,
+            "dominant_emotion": "Happy",
+            "timeline": [
+                {"time": "00:00", "emotion": "Neutral", "confidence": 0.85},
+                {"time": "00:03", "emotion": "Happy", "confidence": 0.92},
+                {"time": "00:06", "emotion": "Happy", "confidence": 0.88},
+                {"time": "00:09", "emotion": "Sad", "confidence": 0.78},
+                {"time": "00:12", "emotion": "Neutral", "confidence": 0.90}
+            ]
+        }
+        
+        with jobs_lock:
+            jobs[job_id]["progress"] = 100
+            jobs[job_id]["status"] = "completed"
+            jobs[job_id]["message"] = "Analysis complete!"
+            jobs[job_id]["results"] = results
+        
+        # Clean up uploaded file after processing (optional)
+        # os.remove(filepath)
+        
+    except Exception as e:
+        with jobs_lock:
+            jobs[job_id]["status"] = "failed"
+            jobs[job_id]["progress"] = 0
+            jobs[job_id]["message"] = f"Processing failed"
+            jobs[job_id]["error"] = str(e)
+
 if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=5000)
+    app.run(
+        debug=config.FLASK_DEBUG,
+        host=config.FLASK_HOST,
+        port=config.FLASK_PORT
+    )

pyproject.toml

@@ -6,8 +6,10 @@ readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "flask>=3.1.2",
+    "flask-cors>=6.0.2",
     "pandas>=2.3.3",
     "plotly>=6.5.2",
+    "python-dotenv>=1.2.1",
     "requests>=2.32.5",
     "streamlit>=1.54.0",
 ]

requirements.txt

@@ -1,7 +1,9 @@
 fastapi
 uvicorn[standard]
 flask
+flask-cors
 streamlit
 requests
 pandas
 plotly
+python-dotenv

streamlit_app.py

@@ -65,6 +65,12 @@ with tab1:
     # Show analyze button
     analyze_btn = st.button("🔍 Analyze Audio", type="primary", use_container_width=True, disabled=(audio_file is None))
     
+    # Initialize session state for results
+    if 'analysis_results' not in st.session_state:
+        st.session_state.analysis_results = None
+    if 'job_id' not in st.session_state:
+        st.session_state.job_id = None
+    
     # Display audio player and file info if file is selected
     if audio_file is not None:
         # Audio player
@@ -87,19 +93,93 @@ with tab1:
                 else:
                     st.metric("File Type", "WAV")
     
-    # Analysis Results Section (placeholder)
+    # Analysis Results Section
     if analyze_btn and audio_file:
-        with st.spinner("🔄 Analyzing audio... Please wait..."):
-            # Placeholder for Flask API call
-            st.info("⚙️ Processing audio through Flask API...")
+        # Upload file to Flask API
+        try:
+            # Prepare file for upload
+            if file_option == "📁 Upload Your File":
+                files = {'file': (file_name, audio_file, 'audio/wav')}
+            else:
+                # For example file, need to reset file pointer
+                audio_file.seek(0)
+                files = {'file': (file_name, audio_file, 'audio/wav')}
             
-        st.success("✅ Analysis Complete!")
+            # Upload to Flask
+            with st.spinner("📤 Uploading audio file..."):
+                upload_response = requests.post(
+                    f"{FLASK_URL}/upload",
+                    files=files
+                )
+            
+            if upload_response.status_code == 202:
+                job_data = upload_response.json()
+                job_id = job_data['job_id']
+                st.session_state.job_id = job_id
+                
+                # Poll for status
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                import time
+                max_attempts = 60  # 60 attempts = 2 minutes max
+                attempt = 0
+                
+                while attempt < max_attempts:
+                    # Check status
+                    status_response = requests.get(f"{FLASK_URL}/status/{job_id}")
+                    
+                    if status_response.status_code == 200:
+                        status_data = status_response.json()
+                        progress = status_data['progress']
+                        message = status_data['message']
+                        status = status_data['status']
+                        
+                        # Update progress
+                        progress_bar.progress(progress / 100)
+                        status_text.text(f"⚙️ {message} ({progress}%)")
+                        
+                        # Check if completed
+                        if status == "completed":
+                            st.session_state.analysis_results = status_data['results']
+                            progress_bar.progress(100)
+                            status_text.empty()
+                            st.success("✅ Analysis Complete!")
+                            break
+                        
+                        elif status == "failed":
+                            error_msg = status_data.get('error', 'Unknown error')
+                            st.error(f"❌ Processing failed: {error_msg}")
+                            progress_bar.empty()
+                            status_text.empty()
+                            break
+                    
+                    # Wait before next poll
+                    time.sleep(2)
+                    attempt += 1
+                
+                if attempt >= max_attempts:
+                    st.error("⏱️ Processing timeout. Please try again.")
+                    
+            else:
+                st.error(f"❌ Upload failed: {upload_response.json().get('error', 'Unknown error')}")
+                
+        except requests.exceptions.ConnectionError:
+            st.error("❌ Could not connect to Flask server. Make sure it's running on port 5000!")
+        except Exception as e:
+            st.error(f"❌ An error occurred: {str(e)}")
+    
+    # Display results if available
+    if st.session_state.analysis_results:
         
         # Results layout
         st.markdown("---")
         st.subheader("📊 Emotion Analysis Results")
         
-        # Sample timeline data with emojis
+        # Get results from session state
+        results = st.session_state.analysis_results
+        
+        # Emotion emoji mapping
         emotion_emoji_map = {
             'Happy': '😊',
             'Sad': '😢',
@@ -107,19 +187,20 @@ with tab1:
             'Neutral': '😐'
         }
         
-        sample_timeline = pd.DataFrame({
-            'Time (s)': ['00:00', '00:05', '00:12', '00:20', '00:30', '00:40'],
-            'Emotion': ['Neutral', 'Happy', 'Sad', 'Happy', 'Angry', 'Neutral'],
-            'Confidence': [0.85, 0.92, 0.78, 0.88, 0.75, 0.90]
-        })
+        # Convert timeline to DataFrame
+        timeline_data = results['timeline']
+        sample_timeline = pd.DataFrame(timeline_data)
+        sample_timeline.rename(columns={'time': 'Time (s)'}, inplace=True)
+        sample_timeline.rename(columns={'emotion': 'Emotion'}, inplace=True)
+        sample_timeline.rename(columns={'confidence': 'Confidence'}, inplace=True)
         
         # Add emoji column
         sample_timeline['Emoji'] = sample_timeline['Emotion'].map(emotion_emoji_map)
         
         # Calculate metrics
-        total_duration = "00:45"
-        unique_emotions = sample_timeline['Emotion'].nunique()
-        dominant_emotion = sample_timeline['Emotion'].mode()[0]
+        total_duration = results['duration']
+        unique_emotions = results['emotions_detected']
+        dominant_emotion = results['dominant_emotion']
         dominant_emoji = emotion_emoji_map[dominant_emotion]
         
         # Metrics