Update app.py

app.py

@@ -13,9 +13,7 @@ from io import BytesIO
 import hashlib
 from audio_recorder_streamlit import audio_recorder
 from transformers import pipeline
-
-
-
+from datetime import datetime
 
 ######################################
 # Voice Input Helper Functions
@@ -35,33 +33,76 @@ def process_audio(audio_bytes):
         waveform = resampler(waveform)
     return {"raw": waveform.numpy().squeeze(), "sampling_rate": 16000}
 
-def get_voice_transcription(state_key):
+def get_voice_transcription(state_key, input_container):
     """Display audio recorder for a given key.
        If new audio is recorded, transcribe it and update the session state.
     """
     if state_key not in st.session_state:
         st.session_state[state_key] = ""
-    # Use a unique key for the recorder widget
-    audio_bytes = audio_recorder(key=state_key + "_audio", 
-                                 pause_threshold=0.8,
-                                 text="Speak to type",
-                                 recording_color="#e8b62c",
-                                 neutral_color="#6aa36f")
+    
+    # Create a unique key for the recorder widget
+    recorder_key = f"{state_key}_audio_{hash(input_container) if input_container else ''}"
+    
+    # Use columns to place mic button inside input field
+    col1, col2 = input_container.columns([0.85, 0.15])
+    
+    # Audio recorder with custom styling
+    audio_bytes = audio_recorder(key=recorder_key,
+                               pause_threshold=1.5,  # Shorter pause for quick responses
+                               text="",
+                               recording_color="#e8b62c",
+                               neutral_color="#6aa36f",
+                               icon_name="microphone",
+                               icon_size="1.5em")
+    
     if audio_bytes:
         current_hash = hashlib.md5(audio_bytes).hexdigest()
         last_hash_key = state_key + "_last_hash"
+        
         if st.session_state.get(last_hash_key, "") != current_hash:
             st.session_state[last_hash_key] = current_hash
+            
+            # Show processing indicator
+            processing_placeholder = input_container.empty()
+            start_time = datetime.now()
+            processing_placeholder.markdown(
+                f"<div style='color: #6C63FF; font-size: 0.8em; margin-top: -10px;'>"
+                f"<i class='fas fa-spinner fa-spin'></i> Processing speech..."
+                f"</div>", 
+                unsafe_allow_html=True
+            )
+            
             try:
                 audio_input = process_audio(audio_bytes)
                 whisper = load_voice_model()
+                
+                # Measure processing time
+                processing_start = time.time()
                 transcribed_text = whisper(audio_input)["text"]
+                processing_time = time.time() - processing_start
+                
+                # For short responses (yes/no/both), use a simpler model if available
+                if len(transcribed_text.split()) <= 2:
+                    transcribed_text = transcribed_text.lower().strip()
+                
                 st.info(f"📝 Transcribed: {transcribed_text}")
+                
+                # Show processing time feedback
+                processing_placeholder.markdown(
+                    f"<div style='color: #6C63FF; font-size: 0.8em; margin-top: -10px;'>"
+                    f"<i class='fas fa-check-circle'></i> Processed in {processing_time:.1f}s"
+                    f"</div>", 
+                    unsafe_allow_html=True
+                )
+                
                 # Append (or set) new transcription
-                st.session_state[state_key] += (" " + transcribed_text).strip()
+                st.session_state[state_key] = transcribed_text
                 st.experimental_rerun()
+                
             except Exception as e:
                 st.error(f"Voice input error: {str(e)}")
+                processing_placeholder.empty()
+    
     return st.session_state[state_key]
 
 ######################################
@@ -122,6 +163,34 @@ def inject_custom_css():
         .progress-fill { height: 100%; background: linear-gradient(90deg, #6C63FF, #3B82F6);
                          transition: width 0.5s ease; }
         .question-count { color: #6C63FF; font-weight: 600; font-size: 0.9rem; margin-bottom: 0.5rem; }
+        .mic-button { position: absolute; right: 10px; top: 50%; transform: translateY(-50%); 
+                      background: none; border: none; cursor: pointer; color: #6C63FF; }
+        .processing-indicator { color: #6C63FF; font-size: 0.8em; margin-top: -10px; }
+        
+        /* Custom audio recorder styles */
+        .audio-recorder {
+            background: none !important;
+            box-shadow: none !important;
+            padding: 0 !important;
+            margin: 0 !important;
+            min-width: auto !important;
+            height: auto !important;
+        }
+        .audio-recorder:hover {
+            transform: scale(1.1) !important;
+        }
+        .audio-recorder svg {
+            color: #6C63FF !important;
+        }
+        .audio-recorder.recording svg {
+            color: #e74c3c !important;
+            animation: pulse 1.5s infinite;
+        }
+        @keyframes pulse {
+            0% { transform: scale(1); }
+            50% { transform: scale(1.2); }
+            100% { transform: scale(1); }
+        }
 
     </style>
     """, unsafe_allow_html=True)
@@ -266,22 +335,33 @@ def main():
 
         with st.form("start_form"):
             # --- Voice Input for Category ---
-            st.markdown("#### Use Voice (English/Urdu) for Category Input")
-            voice_category = get_voice_transcription("voice_category")
-            # The text input now defaults to any spoken words
-            category_input = st.text_input("Enter category (person/place/object):", 
-                                           value=voice_category.strip(), 
-                                           key="category_input").strip().lower()
+            st.markdown("#### Speak your category (person/place/object)")
+            category_container = st.empty()
+            category_input = category_container.text_input(
+                "Enter category (person/place/object):", 
+                key="category_input"
+            )
+            
+            # Get voice transcription and update the input field
+            voice_category = get_voice_transcription("voice_category", category_container)
+            if voice_category and voice_category != category_input:
+                category_container.text_input(
+                    "Enter category (person/place/object):", 
+                    value=voice_category.strip(), 
+                    key="category_input_updated"
+                )
+                
             if st.form_submit_button("Start Game"):
-                if not category_input:
+                final_category = st.session_state.get("voice_category", "").strip() or category_input.strip().lower()
+                if not final_category:
                     st.error("Please enter a category!")
-                elif category_input not in ["person", "place", "object"]:
+                elif final_category not in ["person", "place", "object"]:
                     st.error("Please enter either 'person', 'place', or 'object'!")
                 else:
-                    st.session_state.category = category_input
+                    st.session_state.category = final_category
                     first_question = ask_llama([
                         {"role": "user", "content": "Ask your first strategic yes/no question."}
-                    ], category_input)
+                    ], final_category)
                     st.session_state.questions = [first_question]
                     st.session_state.conversation_history = [
                         {"role": "assistant", "content": first_question}
@@ -318,18 +398,30 @@ def main():
             st.experimental_rerun()
         with st.form("answer_form"):
             # --- Voice Input for Answer ---
-            st.markdown("#### Use Voice (English/Urdu) for Your Answer")
-            voice_answer = get_voice_transcription("voice_answer")
-            answer_input = st.text_input("Your answer (yes/no/both):",
-                                          value=voice_answer.strip(),
-                                          key=f"answer_{st.session_state.current_q}").strip().lower()
+            st.markdown("#### Speak your answer (yes/no/both)")
+            answer_container = st.empty()
+            answer_input = answer_container.text_input(
+                "Your answer (yes/no/both):",
+                key=f"answer_{st.session_state.current_q}"
+            )
+            
+            # Get voice transcription and update the input field
+            voice_answer = get_voice_transcription("voice_answer", answer_container)
+            if voice_answer and voice_answer != answer_input:
+                answer_container.text_input(
+                    "Your answer (yes/no/both):",
+                    value=voice_answer.strip(),
+                    key=f"answer_updated_{st.session_state.current_q}"
+                )
+                
             if st.form_submit_button("Submit"):
-                if answer_input not in ["yes", "no", "both"]:
+                final_answer = st.session_state.get("voice_answer", "").strip().lower() or answer_input.strip().lower()
+                if final_answer not in ["yes", "no", "both"]:
                     st.error("Please answer with 'yes', 'no', or 'both'!")
                 else:
-                    st.session_state.answers.append(answer_input)
+                    st.session_state.answers.append(final_answer)
                     st.session_state.conversation_history.append(
-                        {"role": "user", "content": answer_input}
+                        {"role": "user", "content": final_answer}
                     )
                     next_response = ask_llama(
                         st.session_state.conversation_history,
@@ -347,19 +439,34 @@ def main():
                         if st.session_state.current_q >= 20:
                             st.session_state.game_state = "result"
                     st.experimental_rerun()
+                    
         with st.expander("Need Help? Chat with AI Assistant"):
             # --- Voice Input for Help Query ---
-            st.markdown("#### Use Voice (English/Urdu) for Help Query")
-            voice_help = get_voice_transcription("voice_help")
-            help_query = st.text_input("Enter your help query:", 
-                                       value=voice_help.strip(), 
-                                       key="help_query")
+            st.markdown("#### Speak your help query")
+            help_container = st.empty()
+            help_query = help_container.text_input(
+                "Enter your help query:", 
+                key="help_query"
+            )
+            
+            # Get voice transcription and update the input field
+            voice_help = get_voice_transcription("voice_help", help_container)
+            if voice_help and voice_help != help_query:
+                help_container.text_input(
+                    "Enter your help query:", 
+                    value=voice_help.strip(), 
+                    key="help_query_updated"
+                )
+                
             if st.button("Send", key="send_help"):
-                if help_query:
-                    help_response = ask_help_agent(help_query)
-                    st.session_state.help_conversation.append({"query": help_query, "response": help_response})
+                final_help_query = st.session_state.get("voice_help", "").strip() or help_query.strip()
+                if final_help_query:
+                    help_response = ask_help_agent(final_help_query)
+                    st.session_state.help_conversation.append({"query": final_help_query, "response": help_response})
+                    st.experimental_rerun()
                 else:
                     st.error("Please enter a query!")
+                    
             if st.session_state.help_conversation:
                 for msg in st.session_state.help_conversation:
                     st.markdown(f"**You:** {msg['query']}")
@@ -381,15 +488,30 @@ def main():
         </div>
         ''', unsafe_allow_html=True)
         with st.form("confirm_form"):
-            confirm_input = st.text_input("Type your answer (yes/no/both):", key="confirm_input").strip().lower()
+            # --- Voice Input for Confirmation ---
+            confirm_container = st.empty()
+            confirm_input = confirm_container.text_input(
+                "Type your answer (yes/no/both):", 
+                key="confirm_input"
+            )
+            
+            # Get voice transcription and update the input field
+            voice_confirm = get_voice_transcription("voice_confirm", confirm_container)
+            if voice_confirm and voice_confirm != confirm_input:
+                confirm_container.text_input(
+                    "Type your answer (yes/no/both):", 
+                    value=voice_confirm.strip(), 
+                    key="confirm_input_updated"
+                )
+                
             if st.form_submit_button("Submit"):
-                if confirm_input not in ["yes", "no", "both"]:
+                final_confirm = st.session_state.get("voice_confirm", "").strip().lower() or confirm_input.strip().lower()
+                if final_confirm not in ["yes", "no", "both"]:
                     st.error("Please answer with 'yes', 'no', or 'both'!")
                 else:
-                    if confirm_input == "yes":
+                    if final_confirm == "yes":
                         st.session_state.game_state = "result"
                         st.experimental_rerun()
-                        st.stop()
                     else:
                         st.session_state.conversation_history.append(
                             {"role": "user", "content": "no"}
@@ -430,4 +552,4 @@ def main():
             st.experimental_rerun()
 
 if __name__ == "__main__":
-    main()
+    main()