Enhance Dockerfile and Streamlit configuration; add upload directory, max upload size, and XSRF protection; update README with troubleshooting tips for file uploads

.streamlit/config.toml

@@ -3,6 +3,8 @@ port = 8501
 address = "0.0.0.0"
 headless = true
 enableCORS = false
+maxUploadSize = 200
+enableXsrfProtection = false
 
 [browser]
 gatherUsageStats = false

Dockerfile

@@ -19,7 +19,8 @@ RUN apt-get update && \
     && rm -rf /var/lib/apt/lists/*
 
 # Create necessary directories
-RUN mkdir -p /app/tmp_model /tmp/matplotlib
+RUN mkdir -p /app/tmp_model /tmp/matplotlib /app/uploads
+RUN chmod -R 777 /app/uploads /app/tmp_model /tmp/matplotlib
 
 # Copy requirements first (for better caching)
 COPY requirements.txt .
@@ -39,6 +40,8 @@ RUN echo "[server]" > ./.streamlit/config.toml && \
     echo "port = 8501" >> ./.streamlit/config.toml && \
     echo "address = \"0.0.0.0\"" >> ./.streamlit/config.toml && \
     echo "headless = true" >> ./.streamlit/config.toml && \
+    echo "maxUploadSize = 200" >> ./.streamlit/config.toml && \
+    echo "enableXsrfProtection = false" >> ./.streamlit/config.toml && \
     echo "" >> ./.streamlit/config.toml && \
     echo "[browser]" >> ./.streamlit/config.toml && \
     echo "gatherUsageStats = false" >> ./.streamlit/config.toml && \

README.md

@@ -73,10 +73,25 @@ If you encounter errors like `Sign in to confirm you're not a bot` when using Yo
 The app is containerized with Docker for easy deployment. Use the included Dockerfile to build and run:
 
 ```bash
+# Build the Docker image
 docker build -t accent-detector .
-docker run -p 8501:8501 accent-detector
+
+# Run the container with volume mounting for better file handling
+docker run -p 8501:8501 --volume /tmp/accent-detector:/app/uploads accent-detector 
+
+# For Windows users:
+docker run -p 8501:8501 --volume C:\temp\accent-detector:/app/uploads accent-detector
 ```
 
+### Troubleshooting Upload Issues
+
+If you encounter 403 Forbidden errors when uploading files:
+
+1. Make sure your audio file is under 200MB
+2. Try converting your audio to a WAV or MP3 format
+3. For longer files, consider extracting just the speech segment
+4. If uploading an MP4 video, ensure it's not encrypted or DRM-protected
+
 ## Powered By
 - [SpeechBrain](https://huggingface.co/speechbrain/lang-id-commonlanguage_ecapa)
 - [Hugging Face Transformers](https://huggingface.co/speechbrain/lang-id-voxlingua107-ecapa)

src/streamlit_app.py

@@ -43,17 +43,23 @@ import matplotlib.pyplot as plt
 import tempfile
 import time
 
-# Comment for deployment instructions:
+# Deployment instructions:
 # To deploy this app:
 # 1. Make sure Docker is installed
 # 2. Build the Docker image: docker build -t accent-detector .
-# 3. Run the container: docker run -p 8501:8501 accent-detector
+# 3. Run the container: docker run -p 8501:8501 --volume /tmp/accent-detector:/app/uploads accent-detector
+#    For Windows: docker run -p 8501:8501 --volume C:\temp\accent-detector:/app/uploads accent-detector
 # 4. Access the app at http://localhost:8501
 # 
 # For cloud deployment:
 # - Streamlit Cloud: Connect your GitHub repository to Streamlit Cloud
-# - Hugging Face Spaces: Use the Docker deployment option
-# - Azure/AWS/GCP: Deploy the container using their container services
+# - Hugging Face Spaces: Use the Docker deployment option with proper volume mounts
+# - Azure/AWS/GCP: Deploy the container using their container services with persistent storage
+#
+# Troubleshooting file uploads:
+# - Set maxUploadSize in .streamlit/config.toml
+# - Ensure write permissions on upload directories
+# - For 403 errors, check file size and format compatibility
 
 # Load environment variables (if .env file exists)
 try:
@@ -323,15 +329,52 @@ class AccentDetector:
 
 def process_uploaded_audio(uploaded_file):
     """Process uploaded audio file"""
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
-        temp_file.write(uploaded_file.getvalue())
-        audio_path = temp_file.name
-    
-    detector = AccentDetector()
-    results = detector.analyze_audio(audio_path)
-    
-    # Clean up
-    os.unlink(audio_path)
+    try:
+        # Create a unique filename based on timestamp
+        timestamp = str(int(time.time()))
+        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+        
+        # Write the uploaded file to disk with proper extension
+        temp_input_path = f"uploaded_audio_{timestamp}{file_extension}"
+        with open(temp_input_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+            
+        # For MP4 files, extract the audio using ffmpeg
+        if file_extension == ".mp4":
+            st.info("Extracting audio from video file...")
+            audio_path = f"extracted_audio_{timestamp}.wav"
+            try:
+                subprocess.run(
+                    ['ffmpeg', '-i', temp_input_path, '-vn', '-acodec', 'pcm_s16le', '-ar', '16000', '-ac', '1', audio_path],
+                    check=True,
+                    capture_output=True
+                )
+                # Remove the original video file
+                os.remove(temp_input_path)
+            except subprocess.CalledProcessError as e:
+                st.error(f"Error extracting audio: {e}")
+                st.error(f"ffmpeg output: {e.stderr.decode('utf-8')}")
+                raise
+        else:
+            # For audio files, use them directly
+            audio_path = temp_input_path
+        
+        detector = AccentDetector()
+        results = detector.analyze_audio(audio_path)
+        
+        # Clean up
+        if os.path.exists(audio_path):
+            os.remove(audio_path)
+            
+        return results
+        
+    except Exception as e:
+        st.error(f"Error processing audio: {str(e)}")
+        if 'temp_input_path' in locals() and os.path.exists(temp_input_path):
+            os.remove(temp_input_path)
+        if 'audio_path' in locals() and os.path.exists(audio_path):
+            os.remove(audio_path)
+        raise
     return results
 
 # --- Streamlit App ---
@@ -479,9 +522,16 @@ with tab2:
     st.markdown("### 🎵 Upload Audio File")
     st.caption("**Recommended option!** Direct audio upload is more reliable than video URLs.")
     
+    # Add some information about file size limits 
+    st.info("📝 **File Requirements**:  \n"
+            "• Maximum file size: 200MB  \n"
+            "• Supported formats: WAV, MP3, M4A, OGG, FLAC, MP4  \n"
+            "• Recommended length: 15-60 seconds of clear speech")
+    
     uploaded_file = st.file_uploader("Upload an audio file", 
-                                   type=["wav", "mp3", "m4a", "ogg", "flac"], 
-                                   help="Support for WAV, MP3, M4A, OGG and FLAC formats")
+                                   type=["wav", "mp3", "m4a", "ogg", "flac", "mp4"], 
+                                   help="Support for WAV, MP3, M4A, OGG, FLAC and MP4 formats",
+                                   accept_multiple_files=False)
     
     if uploaded_file is not None:
         # Show a preview of the audio
@@ -494,14 +544,25 @@ with tab2:
             analyze_button = st.button("Analyze Audio", type="primary", use_container_width=True)
         with col2:
             st.caption("Tip: 15-30 seconds of clear speech works best for accent detection")
-        
         if analyze_button:
             with st.spinner("Analyzing audio... (this may take 15-30 seconds)"):
                 try:
-                    results = process_uploaded_audio(uploaded_file)
-                    
-                    # Display results
-                    st.success("✅ Analysis Complete!")
+                    # Check file size before processing
+                    file_size_mb = len(uploaded_file.getvalue()) / (1024 * 1024)
+                    if file_size_mb > 190:  # Stay below the 200MB limit with some buffer
+                        st.error(f"File size ({file_size_mb:.1f}MB) is too large. Maximum allowed is 190MB.")
+                        st.info("Tip: Try trimming your audio to just the speech segment for better results.")
+                    else:
+                        # Check the file type and inform user about processing steps
+                        file_extension = os.path.splitext(uploaded_file.name)[1].lower()
+                        if file_extension == '.mp4':
+                            st.info("Processing video file - extracting audio track...")
+                        
+                        # Process the file
+                        results = process_uploaded_audio(uploaded_file)
+                        
+                        # Display results
+                        st.success("✅ Analysis Complete!")
                     
                     # Create columns for results
                     col1, col2 = st.columns([2, 1])
@@ -511,8 +572,7 @@ with tab2:
                         st.markdown(f"**Detected Accent:** {results['accent']}")
                         st.markdown(f"**English Proficiency:** {results['english_confidence']:.1f}%")
                         st.markdown(f"**Accent Confidence:** {results['accent_confidence']:.1f}%")
-                        
-                        # Show explanation in a box
+                          # Show explanation in a box
                         st.markdown("### Expert Analysis")
                         st.info(results['explanation'])
                     
@@ -520,8 +580,40 @@ with tab2:
                         if results['audio_viz']:
                             st.pyplot(results['audio_viz'])
                 
+                except subprocess.CalledProcessError as e:
+                    st.error("Error processing audio file")
+                    st.error(f"FFmpeg error: {e.stderr.decode('utf-8') if e.stderr else str(e)}")
+                    st.info("Troubleshooting tips:\n"
+                            "• Try a different audio file format (WAV or MP3 recommended)\n"
+                            "• Make sure the file is not corrupted\n"
+                            "• Try a shorter audio clip")
+                    
+                except PermissionError as e:
+                    st.error(f"Permission error: {str(e)}")
+                    st.info("The app doesn't have permission to access or create temporary files. "
+                           "This could be due to Docker container permissions. "
+                           "Contact the administrator or try using a different file.")
+                    
+                except OSError as e:
+                    st.error(f"System error: {str(e)}")
+                    st.info("Check that the file isn't corrupted and try with a smaller audio clip.")
+                    
                 except Exception as e:
-                    st.error(f"Error during analysis: {str(e)}")
+                    error_msg = str(e)
+                    st.error(f"Error during analysis: {error_msg}")
+                    
+                    if "403" in error_msg:
+                        st.warning("Received a 403 Forbidden error. This may be due to: \n"
+                                 "• File size exceeding limits\n"
+                                 "• Temporary file permission issues\n"
+                                 "• Network restrictions")
+                        st.info("Try a smaller audio file (less than 50MB) or a different format.")
+                    elif "timeout" in error_msg.lower():
+                        st.warning("The request timed out. Try a shorter audio clip or check your internet connection.")
+                    elif "memory" in error_msg.lower():
+                        st.warning("Out of memory error. Try a shorter audio clip.")
+                    else:
+                        st.info("If the problem persists, try a different audio file format such as MP3 or WAV.")
 
 # Add footer with deployment info
 st.markdown("---")