Update app.py

app.py

@@ -1,10 +1,9 @@
 """
 LocaleNLP Translation Service
 ============================
-
 A multi-language translation application supporting English, Wolof, Hausa, and Darija.
 Features text, audio, and document translation with automatic chaining for all language pairs.
-
+Includes user feedback logging to CSV.
 Author: LocaleNLP
 """
 
@@ -16,6 +15,8 @@ from typing import Optional, Dict, Tuple, Any, Union
 from pathlib import Path
 from dataclasses import dataclass
 from enum import Enum
+import csv
+from datetime import datetime
 
 import gradio as gr
 import torch
@@ -466,6 +467,64 @@ class TranslationApp:
             
         return ""
     
+    def log_feedback(
+        self,
+        source_lang: Language,
+        target_lang: Language,
+        user_input: str,
+        model_output: str,
+        notation: Optional[float] = None,
+        correct_translation: Optional[str] = None
+    ):
+        """
+        Log user feedback to a CSV file named '{source}_{target}.csv'.
+        
+        Args:
+            source_lang: Source language enum
+            target_lang: Target language enum
+            user_input: Original input text
+            model_output: Model-generated translation
+            notation: User rating (optional)
+            correct_translation: Corrected version (optional)
+        """
+        # Define filename
+        src = source_lang.value.lower()
+        tgt = target_lang.value.lower()
+        filename = f"{src}_{tgt}.csv"
+        
+        # Define headers and row
+        headers = [
+            "timestamp",
+            "source_language",
+            "target_language",
+            "user_input",
+            "model_output",
+            "notation",
+            "correct_translation"
+        ]
+        row = {
+            "timestamp": datetime.now().isoformat(),
+            "source_language": source_lang.value,
+            "target_language": target_lang.value,
+            "user_input": user_input.strip(),
+            "model_output": model_output.strip(),
+            "notation": notation,
+            "correct_translation": correct_translation.strip() if correct_translation else ""
+        }
+        
+        # Check if file exists to determine whether to write headers
+        file_exists = Path(filename).exists()
+
+        try:
+            with open(filename, mode="a", encoding="utf-8", newline="") as f:
+                writer = csv.DictWriter(f, fieldnames=headers)
+                if not file_exists:
+                    writer.writeheader()  # Write header only once
+                writer.writerow(row)
+            logger.info(f"Feedback saved to {filename}")
+        except Exception as e:
+            logger.error(f"Failed to save feedback to {filename}: {e}")
+
     def create_interface(self) -> gr.Blocks:
         """Create and return the Gradio interface."""
         
@@ -536,7 +595,36 @@ class TranslationApp:
                 lines=10,
                 interactive=False
             )
-            
+
+            # --- FEEDBACK SECTION ---
+            gr.Markdown("### 📝 Provide Feedback on Translation")
+
+            with gr.Row():
+                notation = gr.Slider(
+                    minimum=1,
+                    maximum=5,
+                    step=1,
+                    label="Rate translation quality (1-5 stars)",
+                    value=None,
+                    interactive=True
+                )
+
+            correct_translation = gr.Textbox(
+                label="Correct Translation (if incorrect)",
+                placeholder="Please provide the correct version if inaccurate...",
+                lines=4,
+                value=""
+            )
+
+            submit_feedback = gr.Button("📤 Submit Feedback", variant="primary")
+            feedback_status = gr.Textbox(label="Feedback Status", value="", interactive=False)
+
+            # Hidden states to preserve context for feedback
+            user_input_state = gr.State()
+            model_output_state = gr.State()
+            source_lang_state = gr.State()
+            target_lang_state = gr.State()
+
             # Event handlers
             def update_visibility(mode: str) -> Dict[str, Any]:
                 """Update component visibility based on input mode."""
@@ -569,24 +657,61 @@ class TranslationApp:
                     logger.error(f"Processing error: {e}")
                     return "", f"❌ Error: {str(e)}"
             
-            def handle_translate(
+            def handle_translate_with_input(
                 extracted_text: str,
                 source_lang: str,
                 target_lang: str
-            ) -> str:
-                """Handle translation of processed text."""
+            ) -> Tuple[str, str, str]:
+                """Handle translation and return inputs for logging."""
                 if not extracted_text.strip():
-                    return "📝 No text to translate."
+                    return "📝 No text to translate.", "", ""
                 try:
-                    return self.translation_service.translate(
+                    translated = self.translation_service.translate(
                         extracted_text,
                         Language(source_lang),
                         Language(target_lang)
                     )
+                    return translated, extracted_text, source_lang
                 except Exception as e:
                     logger.error(f"Translation error: {e}")
-                    return f"❌ Translation error: {str(e)}"
-            
+                    error_msg = f"❌ Translation error: {str(e)}"
+                    return error_msg, extracted_text, source_lang
+
+            def set_states_for_feedback(
+                output: str,
+                inp: str,
+                src: str,
+                tgt: str
+            ):
+                """Set hidden states for feedback submission."""
+                return inp, output, src, tgt
+
+            def save_feedback(
+                user_input: str,
+                model_output: str,
+                source_lang_str: str,
+                target_lang_str: str,
+                notation_val: float,
+                correct_trans: str
+            ):
+                """Save feedback to CSV."""
+                try:
+                    source_lang = Language(source_lang_str)
+                    target_lang = Language(target_lang_str)
+                    
+                    self.log_feedback(
+                        source_lang=source_lang,
+                        target_lang=target_lang,
+                        user_input=user_input,
+                        model_output=model_output,
+                        notation=notation_val,
+                        correct_translation=correct_trans or None
+                    )
+                    return "✅ Thank you for your feedback!"
+                except Exception as e:
+                    logger.error(f"Feedback submission failed: {e}")
+                    return f"❌ Failed to save feedback: {str(e)}"
+
             # Connect events
             input_mode.change(
                 fn=update_visibility,
@@ -594,14 +719,35 @@ class TranslationApp:
                 outputs=[input_text, audio_input, file_input, extracted_text, output_text]
             )
             
-            translate_btn.click(
+            # Chain: Process → Translate → Store context → Wait for feedback
+            process_event = translate_btn.click(
                 fn=handle_process,
                 inputs=[input_mode, input_lang, input_text, audio_input, file_input],
                 outputs=[extracted_text, output_text]
-            ).then(
-                fn=handle_translate,
+            )
+
+            process_event.success(
+                fn=handle_translate_with_input,
                 inputs=[extracted_text, input_lang, output_lang],
-                outputs=output_text
+                outputs=[output_text, gr.State(), gr.State()]
+            ).success(
+                fn=set_states_for_feedback,
+                inputs=[output_text, extracted_text, input_lang, output_lang],
+                outputs=[user_input_state, model_output_state, source_lang_state, target_lang_state]
+            )
+
+            # Feedback submission
+            submit_feedback.click(
+                fn=save_feedback,
+                inputs=[
+                    user_input_state,
+                    model_output_state,
+                    source_lang_state,
+                    target_lang_state,
+                    notation,
+                    correct_translation
+                ],
+                outputs=feedback_status
             )
         
         return interface