Update app.py

app.py

@@ -1,11 +1,8 @@
 import streamlit as st
-from git import Repo
-import platform
-import git
 import json
 import os
-import time
 from datetime import datetime, timedelta
+import subprocess
 from huggingface_hub import HfApi
 from pathlib import Path
 from calendar_rag import (
@@ -14,21 +11,6 @@ from calendar_rag import (
     PipelineConfig
 )
 
-def get_repo_path():
-    """
-    Get repository path based on the operating system
-    """
-    if platform.system() == 'Windows':
-        return r"D:\Last SWU\swu-chat-bot-project"
-    else:
-        # For Linux/Mac, use the current directory
-        return os.path.join(os.getcwd(), "swu-chat-bot-project")
-        
-# Define repository path
-REPO_PATH = get_repo_path()
-GITHUB_REPO_URL = "https://github.com/jirasaksaimekJijo/swu-chat-bot-project.git"
-
-
 # Custom CSS for enhanced styling
 def load_custom_css():
     st.markdown("""
@@ -102,7 +84,7 @@ def load_custom_css():
             
             .status-offline {
                 background-color: #FDE8E8;
-                color: #ff0000;
+                color: rgb(255, 255, 255);
             }
             </style>
     """, unsafe_allow_html=True)
@@ -140,181 +122,66 @@ def load_qa_history():
         return []
 
 def save_qa_history(history_entry):
-    """
-    Save QA history to Git with improved error handling and logging.
-    """
+    """Save QA history entry to local JSON file and push to Hugging Face"""
     try:
-        # Get repository path
-        repo_path = Path(REPO_PATH)  # Use the global REPO_PATH instead of env variable
-        history_file = repo_path / "qa_history.json"
+        history_file = Path("qa_history.json")
         
-        # Load existing history
-        history_data = []
+        # Initialize or load existing history
         if history_file.exists():
-            try:
-                with open(history_file, "r", encoding="utf-8") as f:
+            with open(history_file, "r", encoding="utf-8") as f:
+                try:
                     history_data = json.load(f)
-            except json.JSONDecodeError:
-                print("Creating new history file")
-        
-        # Update history
-        if isinstance(history_entry, list):
-            history_data.extend(history_entry)
+                except json.JSONDecodeError:
+                    history_data = []
         else:
-            history_data.append(history_entry)
+            history_data = []
+        
+        # Append new entry
+        history_data.append(history_entry)
         
         # Save updated history
-        with open(history_file, "w", encoding="utf-8") as f:
+        with open("qa_history.json", "w", encoding="utf-8") as f:
             json.dump(history_data, f, ensure_ascii=False, indent=2)
         
-        # Git operations
-        repo = Repo(str(repo_path))
-        
-        # Check if the file is tracked
-        current_files = repo.git.ls_files().split('\n')
-        if str(history_file.relative_to(repo_path)) not in current_files:
-            repo.index.add([str(history_file)])
-            print(f"Added new file: {history_file}")
-        else:
-            repo.index.add([str(history_file)])
-            print(f"Updated existing file: {history_file}")
-        
-        if repo.is_dirty(untracked_files=True):
-            commit = repo.index.commit(f"Update QA history at {datetime.now().isoformat()}")
-            origin = repo.remote('origin')
-            
-            try:
-                origin.push()
-                print(f"Successfully pushed commit {commit.hexsha}")
-                return True
-            except git.GitCommandError as push_error:
-                print(f"Push error: {str(push_error)}")
-                if "Authentication failed" in str(push_error):
-                    print("Authentication failed - please check your Git credentials")
-                return False
-        else:
-            print("No changes to commit")
-            return True
-            
+        # Push to Hugging Face
+        hf_token = os.getenv('HF_TOKEN') or st.secrets['HF_TOKEN']
+        api = HfApi(token=hf_token)
+        api.upload_file(
+            path_or_fileobj="qa_history.json",
+            path_in_repo="qa_history.json",
+            repo_id="JirasakJo/Questions_Graduate_Studies_Calendar_2024",
+            repo_type="space"
+        )
     except Exception as e:
-        print(f"Save operation failed: {str(e)}")
-        return False
+        st.error(f"Error saving QA history: {str(e)}")
 
 def add_to_qa_history(query: str, answer: str):
-    """Add new QA pair to history with immediate save attempt"""
+    """Add new QA pair to history"""
     history_entry = {
         "timestamp": (datetime.now() + timedelta(hours=7)).isoformat(),
         "query": query,
         "answer": answer
     }
     
-    # Append to session state history
-    if 'all_history' not in st.session_state:
-        st.session_state.all_history = []
-    st.session_state.all_history.append(history_entry)
-    
-    # Immediately try to save if GitHub sync is enabled
-    if st.session_state.github_sync_enabled:
-        success = save_qa_history(history_entry)
-        if not success:
-            print("Failed to save QA history to GitHub")
-    
+    save_qa_history(history_entry)
     return history_entry
 
-def fix_repo_path():
-    """
-    Fix repository path for Windows environments
-    """
-    # Define the correct Windows path
-    windows_path = r"D:\Last SWU\swu-chat-bot-project"
-    
-    # Set the environment variable with the correct path
-    if platform.system() == 'Windows':
-        os.environ["GITHUB_REPO_PATH"] = windows_path
-    else:
-        # Convert Windows path to the current OS format
-        os.environ["GITHUB_REPO_PATH"] = str(Path(windows_path))
-    
-    return os.environ["GITHUB_REPO_PATH"]
-
-# Add this at the start of your main() function
-def initialize_paths():
-    """
-    Initialize and verify repository paths
-    """
-    repo_path = fix_repo_path()
-    print(f"Repository path set to: {repo_path}")
-    
-    # Verify the path exists
-    path_exists = os.path.exists(repo_path)
-    git_dir_exists = os.path.exists(os.path.join(repo_path, '.git'))
-    
-    print(f"Repository path exists: {path_exists}")
-    print(f"Git directory exists: {git_dir_exists}")
-    
-    return path_exists and git_dir_exists
-    
-def check_git_config():
-    """
-    Check and verify Git configuration
-    """
-    try:
-        repo_path = Path(os.getenv('GITHUB_REPO_PATH', '')).resolve()
-        repo = Repo(str(repo_path))
-        
-        # Check Git configuration
-        config = repo.config_reader()
-        
-        # Get user information
-        try:
-            user_name = config.get_value("user", "name")
-            user_email = config.get_value("user", "email")
-            print(f"Git User: {user_name}")
-            print(f"Git Email: {user_email}")
-        except Exception:
-            print("❌ Git user configuration not found!")
-            return False
-            
-        # Check credential helper
-        try:
-            credential_helper = config.get_value("credential", "helper")
-            print(f"Credential helper: {credential_helper}")
-        except Exception:
-            print("⚠️ No credential helper configured")
-            
-        return True
-        
-    except Exception as e:
-        print(f"❌ Git configuration error: {str(e)}")
-        return False
-        
 def clear_qa_history():
-    """Clear QA history and sync with all storages"""
+    """Clear QA history file"""
     try:
-        # Clear session state
-        st.session_state.all_history = []
-        
-        # Clear local file
+        # Write empty list to history file
         with open("qa_history.json", "w", encoding="utf-8") as f:
             json.dump([], f, ensure_ascii=False, indent=2)
         
-        # Push to GitHub
-        if st.session_state.github_sync_enabled:
-            save_qa_history([])
-        
         # Push to Hugging Face
-        try:
-            hf_token = os.getenv('HF_TOKEN') or st.secrets['HF_TOKEN']
-            api = HfApi(token=hf_token)
-            api.upload_file(
-                path_or_fileobj="qa_history.json",
-                path_in_repo="qa_history.json",
-                repo_id="JirasakJo/Questions_Graduate_Studies_Calendar_2024",
-                repo_type="space"
-            )
-        except Exception as hf_error:
-            print(f"Hugging Face sync failed: {str(hf_error)}")
-            
+        hf_token = os.getenv('HF_TOKEN') or st.secrets['HF_TOKEN']
+        api = HfApi(token=hf_token)
+        api.upload_file(
+            path_or_fileobj="qa_history.json",
+            path_in_repo="qa_history.json",
+            repo_id="JirasakJo/Questions_Graduate_Studies_Calendar_2024",
+            repo_type="space"
+        )
     except Exception as e:
         st.error(f"Error clearing QA history: {str(e)}")
         
@@ -324,12 +191,9 @@ def add_to_history(role: str, message: str):
     
     # If this is an assistant response, save the QA pair
     if role == "assistant" and len(st.session_state.chat_history) >= 2:
+        # Get the corresponding user query (previous message)
         user_query = st.session_state.chat_history[-2][1]
-        history_entry = add_to_qa_history(user_query, message)
-        
-        # Save to storage if GitHub sync is enabled
-        if st.session_state.github_sync_enabled:
-            save_qa_history(history_entry)
+        add_to_qa_history(user_query, message)
     
 def display_chat_history():
     """Display chat history with enhanced styling"""
@@ -349,208 +213,9 @@ def display_chat_history():
                 </div>
             """, unsafe_allow_html=True)
 
-def ensure_repo_exists():
-    """
-    Ensure the repository exists and is properly initialized
-    """
-    try:
-        repo_path = Path(REPO_PATH)
-        
-        # Create directory if it doesn't exist
-        repo_path.mkdir(parents=True, exist_ok=True)
-        
-        # Initialize repository if .git doesn't exist
-        if not (repo_path / '.git').exists():
-            try:
-                # Initialize new repository
-                repo = Repo.init(str(repo_path))
-                
-                # Add remote
-                try:
-                    origin = repo.remote('origin')
-                except ValueError:
-                    origin = repo.create_remote('origin', GITHUB_REPO_URL)
-                
-                # Set up Git configuration
-                with repo.config_writer() as config:
-                    config.set_value("user", "name", "jirasaksaimekJijo")
-                    config.set_value("user", "email", "[email protected]")
-                
-                print(f"Repository initialized at {repo_path}")
-                return True
-                
-            except Exception as init_error:
-                print(f"Failed to initialize repository: {str(init_error)}")
-                return False
-        else:
-            print(f"Repository already exists at {repo_path}")
-            return True
-            
-    except Exception as e:
-        print(f"Failed to ensure repository exists: {str(e)}")
-        return False
-        
-def initialize_github_sync():
-    """
-    Initialize GitHub repository connection with proper path verification
-    """
-    try:
-        # Ensure repository exists
-        if not ensure_repo_exists():
-            return False
-            
-        repo_path = Path(REPO_PATH)
-        print(f"Initializing repo at: {repo_path}")
-        
-        try:
-            # Initialize repository
-            repo = Repo(str(repo_path))
-            
-            # Check remote configuration
-            try:
-                origin = repo.remote('origin')
-                urls = list(origin.urls)
-                if not urls:
-                    print("Remote 'origin' has no URL")
-                    return False
-                
-                print(f"Connected to remote: {urls[0]}")
-                
-                # Test Git operations
-                try:
-                    status = repo.git.status()
-                    print("Git status verified:")
-                    print(status)
-                    return True
-                    
-                except git.GitCommandError as git_error:
-                    print(f"Git command error: {str(git_error)}")
-                    return False
-                    
-            except ValueError as remote_error:
-                print(f"Remote error: {str(remote_error)}")
-                return False
-                
-        except Exception as repo_error:
-            print(f"Repository error: {str(repo_error)}")
-            return False
-            
-    except Exception as e:
-        print(f"Initialization error: {str(e)}")
-        return False
-
-# Initialize global state
-if 'all_history' not in st.session_state:
-    st.session_state.all_history = []
-    
-# Add this function to test the connection
-def test_github_connection():
-    """
-    Test GitHub connection by attempting a simple operation
-    """
-    try:
-        repo_path = Path(r"D:\Last SWU\swu-chat-bot-project")
-        repo = Repo(str(repo_path))
-        
-        # Get current status
-        status = repo.git.status()
-        print("Repository Status:")
-        print(status)
-        
-        # Get remote information
-        origin = repo.remote('origin')
-        print("\nRemote URLs:")
-        for url in origin.urls:
-            print(url)
-            
-        # Get current branch
-        branch = repo.active_branch
-        print(f"\nActive branch: {branch.name}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"Connection test failed: {str(e)}")
-        return False
-        
-def debug_github_connection():
-    """
-    Debug GitHub connection issues and print detailed status
-    """
-    try:
-        # 1. Check repository path
-        repo_path = Path(os.getenv('GITHUB_REPO_PATH', '')).resolve()
-        print(f"1. Checking repository path: {repo_path}")
-        if not repo_path.exists():
-            print("❌ Repository path does not exist!")
-            return False
-        print("✅ Repository path exists")
-
-        # 2. Check .git directory
-        git_dir = repo_path / '.git'
-        print(f"2. Checking .git directory: {git_dir}")
-        if not git_dir.exists():
-            print("❌ .git directory not found!")
-            return False
-        print("✅ .git directory found")
-
-        # 3. Initialize repository
-        try:
-            repo = Repo(str(repo_path))
-            print("3. Repository initialized successfully")
-        except Exception as repo_error:
-            print(f"❌ Failed to initialize repository: {str(repo_error)}")
-            return False
-
-        # 4. Check remote configuration
-        try:
-            origin = repo.remote('origin')
-            urls = list(origin.urls)
-            print(f"4. Remote URLs found: {urls}")
-            
-            if not urls:
-                print("❌ No remote URLs configured!")
-                return False
-            print("✅ Remote URL configured correctly")
-
-            # 5. Check Git credentials
-            try:
-                repo.git.status()
-                print("5. Git status check passed")
-            except git.GitCommandError as status_error:
-                print(f"❌ Git status check failed: {str(status_error)}")
-                return False
-
-            # 6. Test basic Git operations
-            test_file = repo_path / 'test_sync.txt'
-            try:
-                # Create test file
-                test_file.write_text("test sync")
-                repo.index.add([str(test_file)])
-                repo.index.commit("Test sync commit")
-                print("6. Test commit created successfully")
-                
-                # Try to push
-                origin.push()
-                print("✅ Push successful!")
-                
-                # Clean up test file
-                test_file.unlink()
-                return True
-                
-            except git.GitCommandError as push_error:
-                print(f"❌ Push failed: {str(push_error)}")
-                if "Authentication failed" in str(push_error):
-                    print("💡 Authentication error - please check your Git credentials")
-                return False
-                
-        except ValueError as remote_error:
-            print(f"❌ Remote configuration error: {str(remote_error)}")
-            return False
-            
-    except Exception as e:
-        print(f"❌ General error: {str(e)}")
-        return False
+# # Initialize global state
+# if 'all_history' not in st.session_state:
+#     st.session_state.all_history = []
         
 def main():
     # Page config
@@ -574,9 +239,6 @@ def main():
     if 'chat_history' not in st.session_state:
         st.session_state.chat_history = []
     
-    if 'github_sync_enabled' not in st.session_state:
-        st.session_state.github_sync_enabled = repo_exists and initialize_github_sync()
-
     # Load QA history at startup
     if 'qa_history_loaded' not in st.session_state:
         st.session_state.qa_history_loaded = True
@@ -684,40 +346,6 @@ def main():
                 st.session_state.chat_history = []
                 clear_qa_history()  # This function handles both local and remote clearing
                 st.rerun()
-    
-    with info_col:
-        # GitHub Sync Status
-        with st.expander("🔧 GitHub Connection Status", expanded=True):
-            col1, col2 = st.columns([1, 2])
-            
-            with col1:
-                if st.button("Test Connection"):
-                    with st.spinner("Testing connection..."):
-                        if test_github_connection():
-                            st.success("✅ GitHub connection successful!")
-                            st.session_state.github_sync_enabled = True
-                        else:
-                            st.error("❌ GitHub connection failed!")
-                            st.session_state.github_sync_enabled = False
-            
-            with col2:
-                # Display current status
-                status = "🟢 Connected" if st.session_state.github_sync_enabled else "🔴 Disconnected"
-                st.info(f"Current Status: {status}")
-                
-            # Show repository details
-            if st.checkbox("Show Repository Details"):
-                try:
-                    repo = Repo(str(Path(REPO_PATH)))
-                    st.write("Repository Information:")
-                    st.code(f"""
-        Path: {REPO_PATH}
-        Remote URL: {list(repo.remote('origin').urls)[0]}
-        Current Branch: {repo.active_branch.name}
-        Git Status: {repo.git.status()}
-                    """)
-                except Exception as e:
-                    st.error(f"Error accessing repository: {str(e)}")
 
         # System information
         st.markdown("""