Update app.py

app.py

@@ -29,7 +29,6 @@ import chardet
 from transformers import pipeline, MarianTokenizer, AutoModelForSeq2SeqLM
 from huggingface_hub import login
 import base64
-import io
 
 # ================================
 # Configuration & Constants
@@ -101,6 +100,9 @@ GITHUB_REPO = "mgolomanta/Models_Evaluation"
 EVALUATION_FILE = "evaluation.csv"
 GITHUB_TOKEN = os.getenv("git_tk")  # Set this in your environment variables
 
+# Local fallback file
+LOCAL_EVALUATION_FILE = "evaluation.csv"
+
 # ================================
 # Logging Configuration
 # ================================
@@ -442,11 +444,14 @@ class AudioProcessor:
 # ================================
 
 class EvaluationService:
-    """Handles evaluation submissions and GitHub storage."""
+    """Handles evaluation submissions with GitHub and local fallback."""
     
     @staticmethod
     def escape_csv_field(text):
         """Escape text for CSV format."""
+        if text is None:
+            return ""
+        text = str(text)
         if '"' in text:
             text = text.replace('"', '""')
         if ',' in text or '"' in text or '\n' in text:
@@ -454,35 +459,47 @@ class EvaluationService:
         return text
     
     @staticmethod
-    def get_github_file_sha() -> Optional[str]:
-        """Get the SHA of the existing evaluation file on GitHub."""
-        try:
-            url = f"https://api.github.com/repos/{GITHUB_REPO}/contents/{EVALUATION_FILE}"
-            headers = {"Authorization": f"token {GITHUB_TOKEN}"} if GITHUB_TOKEN else {}
-            response = requests.get(url, headers=headers)
-            
-            if response.status_code == 200:
-                return response.json().get("sha")
-            return None
-        except Exception as e:
-            logger.error(f"Error getting file SHA: {e}")
-            return None
+    def ensure_local_csv_exists():
+        """Ensure local CSV file exists with headers."""
+        if not os.path.exists(LOCAL_EVALUATION_FILE):
+            headers = "source_language_name,target_language_name,user_input,model_output,notation_value,correct_answer\n"
+            with open(LOCAL_EVALUATION_FILE, 'w', encoding='utf-8', newline='') as f:
+                f.write(headers)
     
     @staticmethod
-    def read_existing_csv_content() -> str:
-        """Read existing CSV content from GitHub."""
+    def save_evaluation_locally(
+        source_lang: str,
+        target_lang: str,
+        user_input: str,
+        model_output: str,
+        notation: Optional[str] = None,
+        correct_answer: Optional[str] = None
+    ) -> str:
+        """Save evaluation to local CSV file."""
         try:
-            url = f"https://api.github.com/repos/{GITHUB_REPO}/contents/{EVALUATION_FILE}"
-            headers = {"Authorization": f"token {GITHUB_TOKEN}"} if GITHUB_TOKEN else {}
-            response = requests.get(url, headers=headers)
+            # Ensure file exists with headers
+            EvaluationService.ensure_local_csv_exists()
+            
+            # Escape fields for CSV
+            source_lang_escaped = EvaluationService.escape_csv_field(source_lang)
+            target_lang_escaped = EvaluationService.escape_csv_field(target_lang)
+            user_input_escaped = EvaluationService.escape_csv_field(user_input)
+            model_output_escaped = EvaluationService.escape_csv_field(model_output)
+            notation_escaped = EvaluationService.escape_csv_field(notation)
+            correct_answer_escaped = EvaluationService.escape_csv_field(correct_answer)
+            
+            # Prepare the new evaluation data
+            new_row = f"{source_lang_escaped},{target_lang_escaped},{user_input_escaped},{model_output_escaped},{notation_escaped},{correct_answer_escaped}\n"
+            
+            # Append to file
+            with open(LOCAL_EVALUATION_FILE, 'a', encoding='utf-8', newline='') as f:
+                f.write(new_row)
+            
+            return "✅ Evaluation saved locally!"
             
-            if response.status_code == 200:
-                content = response.json().get("content", "")
-                return base64.b64decode(content).decode('utf-8')
-            return ""
         except Exception as e:
-            logger.error(f"Error reading existing CSV: {e}")
-            return ""
+            logger.error(f"Failed to save evaluation locally: {e}")
+            return f"❌ Error saving evaluation locally: {str(e)}"
     
     @staticmethod
     def save_evaluation_to_github(
@@ -494,7 +511,7 @@ class EvaluationService:
         correct_answer: Optional[str] = None
     ) -> str:
         """
-        Save evaluation to GitHub CSV file.
+        Save evaluation to GitHub CSV file with fallback to local storage.
         
         Args:
             source_lang: Source language name
@@ -508,19 +525,43 @@ class EvaluationService:
             Status message
         """
         try:
+            # First try to save to GitHub
+            if not GITHUB_TOKEN:
+                # Fallback to local if no token
+                return EvaluationService.save_evaluation_locally(
+                    source_lang, target_lang, user_input, model_output, notation, correct_answer
+                )
+            
             # Escape fields for CSV
             source_lang_escaped = EvaluationService.escape_csv_field(source_lang)
             target_lang_escaped = EvaluationService.escape_csv_field(target_lang)
             user_input_escaped = EvaluationService.escape_csv_field(user_input)
             model_output_escaped = EvaluationService.escape_csv_field(model_output)
-            notation_escaped = EvaluationService.escape_csv_field(notation if notation else "")
-            correct_answer_escaped = EvaluationService.escape_csv_field(correct_answer if correct_answer else "")
+            notation_escaped = EvaluationService.escape_csv_field(notation)
+            correct_answer_escaped = EvaluationService.escape_csv_field(correct_answer)
             
             # Prepare the new evaluation data
             new_row = f"{source_lang_escaped},{target_lang_escaped},{user_input_escaped},{model_output_escaped},{notation_escaped},{correct_answer_escaped}\n"
             
-            # Get existing content
-            existing_content = EvaluationService.read_existing_csv_content()
+            # Try to read existing content from GitHub
+            existing_content = ""
+            file_sha = None
+            
+            try:
+                url = f"https://api.github.com/repos/{GITHUB_REPO}/contents/{EVALUATION_FILE}"
+                headers = {
+                    "Authorization": f"token {GITHUB_TOKEN}",
+                    "Accept": "application/vnd.github.v3+json"
+                }
+                response = requests.get(url, headers=headers)
+                
+                if response.status_code == 200:
+                    file_data = response.json()
+                    file_sha = file_data.get("sha")
+                    content = file_data.get("content", "")
+                    existing_content = base64.b64decode(content).decode('utf-8')
+            except Exception as e:
+                logger.warning(f"Could not read existing GitHub file: {e}")
             
             # Check if file exists and has headers
             if existing_content.strip():
@@ -541,9 +582,6 @@ class EvaluationService:
                 "Accept": "application/vnd.github.v3+json"
             }
             
-            # Check if file exists to get SHA
-            file_sha = EvaluationService.get_github_file_sha()
-            
             # Prepare payload
             payload = {
                 "message": "Add new evaluation",
@@ -561,11 +599,17 @@ class EvaluationService:
                 return "✅ Evaluation submitted successfully to GitHub!"
             else:
                 logger.error(f"GitHub API error: {response.status_code} - {response.text}")
-                return f"❌ Error saving evaluation to GitHub: {response.status_code}"
+                # Fallback to local storage
+                return EvaluationService.save_evaluation_locally(
+                    source_lang, target_lang, user_input, model_output, notation, correct_answer
+                )
                 
         except Exception as e:
             logger.error(f"Failed to save evaluation to GitHub: {e}")
-            return f"❌ Error saving evaluation: {str(e)}"
+            # Fallback to local storage
+            return EvaluationService.save_evaluation_locally(
+                source_lang, target_lang, user_input, model_output, notation, correct_answer
+            )
 
 # ================================
 # Main Application
@@ -628,10 +672,7 @@ class TranslationApp:
         notation: Optional[str],
         correct_answer: Optional[str]
     ) -> str:
-        """Submit evaluation data to GitHub."""
-        if not GITHUB_TOKEN:
-            return "❌ GitHub token not configured. Please set GITHUB_TOKEN environment variable."
-        
+        """Submit evaluation data."""
         if not user_input.strip() or not model_output.strip():
             return "⚠️ Please translate text before submitting evaluation."
             
@@ -844,9 +885,9 @@ def main():
     """Main application entry point."""
     # Check if GitHub token is set
     if not os.getenv("git_tk"):
-        logger.warning("GITHUB_TOKEN environment variable not set. Evaluation submissions will fail.")
+        logger.warning("GITHUB_TOKEN environment variable not set. Evaluations will be saved locally.")
         print("⚠️  WARNING: GITHUB_TOKEN environment variable not set!")
-        print("   Please set it to enable evaluation submissions to GitHub.")
+        print("   Evaluations will be saved to local file only.")
     
     try:
         app = TranslationApp()