Update app.py

app.py

@@ -165,119 +165,105 @@ def load_qa_history():
 def save_qa_history(history_entry):
     """Save QA history entry to local JSON file and push to GitHub"""
     try:
-        history_file = Path("qa_history.json")
+        import requests
+        import base64
+        import json
+        from pathlib import Path
         
-        # Initialize or load existing history
-        if history_file.exists():
+        # GitHub API configuration
+        REPO_OWNER = "jirasaksaimekJijo"
+        REPO_NAME = "swu-chat-bot-project"
+        FILE_PATH = "qa_history.json"
+        GITHUB_TOKEN = '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'
+        
+        # First, load existing data from GitHub
+        api_url = f"https://api.github.com/repos/{REPO_OWNER}/{REPO_NAME}/contents/{FILE_PATH}"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "Authorization": f"token {GITHUB_TOKEN}"
+        }
+        
+        # Try to get existing file first
+        response = requests.get(api_url, headers=headers)
+        
+        # Initialize empty history data
+        history_data = []
+        sha = None
+        
+        if response.status_code == 200:
+            # File exists, get its content and SHA
+            content_data = response.json()
+            sha = content_data["sha"]
+            
             try:
-                with open(history_file, "r", encoding="utf-8") as f:
-                    file_content = f.read()
-                    
+                # Decode and parse existing content
+                file_content = base64.b64decode(content_data["content"]).decode("utf-8")
                 
-                if not file_content.strip():
-                    st.warning("JSON file is empty, initializing new history")
-                    history_data = []
-                else:
-                    try:
-                        history_data = json.loads(file_content)
-                        if not isinstance(history_data, list):
-                            st.error("JSON file does not contain a list, resetting history")
-                            history_data = []
-                    except json.JSONDecodeError as json_err:
-                        st.error(f"JSON parsing error: {str(json_err)}")
-                        # Try to salvage valid JSON if possible
-                        try:
-                            # Remove any trailing commas
-                            file_content = file_content.replace(",]", "]").replace(",}", "}")
-                            history_data = json.loads(file_content)
-                        except:
-                            st.error("Could not salvage JSON, initializing new history")
-                            history_data = []
-            except Exception as file_err:
-                st.error(f"File reading error: {str(file_err)}")
-                history_data = []
+                if file_content.strip():  # Make sure content is not empty
+                    history_data = json.loads(file_content)
+                    
+                    # Ensure history_data is a list
+                    if not isinstance(history_data, list):
+                        st.warning("Existing history data is not a list. Initializing new list.")
+                        history_data = []
+            except Exception as e:
+                st.warning(f"Error parsing existing history: {e}. Initializing new list.")
+        elif response.status_code == 404:
+            # File doesn't exist yet
+            st.info("Creating new QA history file.")
         else:
-            history_data = []
+            st.error(f"Failed to check existing history: {response.status_code} - {response.reason}")
         
-        # Append new entry
+        # Process history entry before appending
+        if isinstance(history_entry, dict) and all(key in history_entry for key in ["timestamp", "query", "answer"]):
+            # Process answer if it's a dict
+            if isinstance(history_entry["answer"], dict):
+                history_entry["answer"] = history_entry["answer"].get('answer', str(history_entry["answer"]))
+            # Process answer if it's a Document-like object
+            elif hasattr(history_entry["answer"], 'content'):
+                history_entry["answer"] = history_entry["answer"].content
+            # Convert to string for any other type
+            else:
+                history_entry["answer"] = str(history_entry["answer"])
+        
+        # Append new entry to history data
         history_data.append(history_entry)
         
-        # Validate history data before saving
-        if not isinstance(history_data, list):
-            st.error("Invalid history data format, must be a list")
-            history_data = []
-            
-        # Process and validate each entry
-        processed_history = []
-        for entry in history_data:
-            if isinstance(entry, dict) and all(key in entry for key in ["timestamp", "query", "answer"]):
-                # Process answer if it's a Document or dict
-                if isinstance(entry["answer"], dict):
-                    entry["answer"] = entry["answer"].get('answer', str(entry["answer"]))
-                elif hasattr(entry["answer"], 'content'):
-                    entry["answer"] = entry["answer"].content
-                else:
-                    entry["answer"] = str(entry["answer"])
-                processed_history.append(entry)
-                
-        history_data = processed_history
-            
-        # Save updated history locally
+        # Also save locally for backup
         try:
-            json_content = json.dumps(history_data, ensure_ascii=False, indent=2)
-            with open("qa_history.json", "w", encoding="utf-8") as f:
-                f.write(json_content)
-        except Exception as save_err:
-            st.error(f"Error saving history locally: {str(save_err)}")
-            return
+            local_path = Path("qa_history.json")
+            with open(local_path, "w", encoding="utf-8") as f:
+                json.dump(history_data, f, ensure_ascii=False, indent=2)
+        except Exception as local_err:
+            st.warning(f"Failed to save local backup: {local_err}")
+        
+        # Prepare content for GitHub
+        updated_content = json.dumps(history_data, ensure_ascii=False, indent=2)
+        encoded_content = base64.b64encode(updated_content.encode('utf-8')).decode('utf-8')
+        
+        # Prepare the update/create payload
+        data = {
+            "message": "Update QA history",
+            "content": encoded_content,
+        }
+        
+        if sha:  # If file exists, include its SHA
+            data["sha"] = sha
+        
+        # Update or create the file
+        update_response = requests.put(api_url, headers=headers, json=data)
+        
+        if update_response.status_code in [200, 201]:
+            return True
+        else:
+            st.error(f"Failed to update QA history: {update_response.status_code} - {update_response.text}")
+            return False
         
-        # Push to GitHub with error logging
-        github_token = os.getenv('GITHUB_TOKEN') or st.secrets.get('GITHUB_TOKEN')
-        if not github_token:
-            st.error("GitHub token not found in environment or secrets!")
-            return
-            
-        try:
-            from github import Github
-            g = Github(github_token)
-                        
-            repo = g.get_repo("jirasaksaimekJijo/swu-chat-bot-project")
-            
-            try:
-                # Try to get the file first
-                contents = repo.get_contents("qa_history.json")
-                
-                # Ensure content is properly encoded
-                content = json.dumps(history_data, ensure_ascii=False, indent=2)
-                
-                response = repo.update_file(
-                    path="qa_history.json",
-                    message="Update QA history",
-                    content=content,
-                    sha=contents.sha,
-                    branch="main"  # Explicitly specify branch
-                )
-                
-            except Exception as file_error:
-                # File doesn't exist, create it
-                content = json.dumps(history_data, ensure_ascii=False, indent=2)
-                response = repo.create_file(
-                    path="qa_history.json",
-                    message="Create QA history",
-                    content=content,
-                    branch="main"  # Explicitly specify branch
-                )
-                st.success("Successfully created qa_history.json on GitHub")
-                
-        except Exception as github_error:
-            st.error(f"GitHub API error: {str(github_error)}")
-            import traceback
-            st.error(f"Full GitHub error trace: {traceback.format_exc()}")
-            
     except Exception as e:
-        st.error(f"General error in save_qa_history: {str(e)}")
         import traceback
-        st.error(f"Full error trace: {traceback.format_exc()}")
+        st.error(f"Error in save_qa_history: {str(e)}")
+        st.error(f"Traceback: {traceback.format_exc()}")
+        return False
         
 def add_to_qa_history(query: str, answer: str):
     """Add new QA pair to history with validation"""