new changes

app.py

@@ -5,6 +5,7 @@ import uuid
 from datetime import datetime
 from pathlib import Path
 import fcntl
+import tempfile
 import pandas as pd
 import pytz
 import streamlit as st
@@ -59,6 +60,61 @@ scheduler = CommitScheduler(
 )
 
 
+def safe_write_json(data, file_path):
+    """Safely write JSON data with atomic write pattern"""
+    try:
+        file_path = Path(file_path)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write to temporary file first
+        with tempfile.NamedTemporaryFile(
+            mode='w',
+            dir=file_path.parent,
+            prefix=file_path.stem,
+            suffix='.tmp',
+            delete=False
+        ) as tmp_file:
+            json.dump(data, tmp_file, ensure_ascii=False, indent=4)
+            tmp_file.flush()
+            os.fsync(tmp_file.fileno())
+        
+        # Atomic rename
+        os.replace(tmp_file.name, file_path)
+        return True
+    except Exception as e:
+        st.error(f"Error writing JSON file: {e}")
+        try:
+            os.unlink(tmp_file.name)
+        except:
+            pass
+        return False
+
+def safe_load_json(file_path):
+    """Safely load JSON data with file locking"""
+    try:
+        file_path = Path(file_path)
+        if not file_path.exists():
+            return {}
+            
+        with open(file_path, 'r', encoding='utf-8') as f:
+            fcntl.flock(f, fcntl.LOCK_SH)
+            try:
+                data = json.load(f)
+                # Basic validation
+                if not isinstance(data, dict):
+                    st.error("Invalid JSON structure - expected dictionary")
+                    return {}
+                return data
+            except json.JSONDecodeError:
+                st.error("Invalid JSON file - contains syntax errors")
+                return {}
+            finally:
+                fcntl.flock(f, fcntl.LOCK_UN)
+    except Exception as e:
+        st.error(f"Error loading JSON file: {e}")
+        return {}
+
+
 def load_data(file_path):
     """
     Load data from a JSON or CSV file with better error handling.
@@ -225,28 +281,25 @@ def calculate_max_bid_points(user_name):
 
 
 def load_users(users_json_path):
-    """Load users data with file locking to prevent corruption"""
+    """Load users data with automatic fallback to Hugging Face"""
+    # First try local file
+    local_data = safe_load_json(users_json_path)
+    if local_data:
+        return local_data
+    
+    # If local file fails, try Hugging Face
     try:
-        if not os.path.exists(users_json_path):
-            return {}
+        users = load_dataset("Jay-Rajput/DIS_IPL_Leads", split="train")
+        users_dict = {}
+        for user_name, user_data in users.to_dict().items():
+            users_dict[user_name] = user_data[0]  # Extract from list
             
-        with open(users_json_path, 'r', encoding='utf-8') as f:
-            # Acquire shared lock for reading
-            fcntl.flock(f, fcntl.LOCK_SH)
-            try:
-                data = json.load(f)
-                # Validate data structure
-                if not all(isinstance(v, dict) and 'points' in v for v in data.values()):
-                    st.error("Invalid users data structure")
-                    return {}
-                return data
-            except json.JSONDecodeError:
-                st.error("Invalid JSON in users file")
-                return {}
-            finally:
-                fcntl.flock(f, fcntl.LOCK_UN)
+        # Save to local file for next time
+        if users_dict and safe_write_json(users_dict, users_json_path):
+            return users_dict
+        return {}
     except Exception as e:
-        st.error(f"Error loading users: {e}")
+        st.error(f"Error loading from Hugging Face: {e}")
         return {}
 
 
@@ -490,16 +543,12 @@ def load_and_process_users():
 
 def update_leaderboard_and_outcomes(match_id, winning_team, man_of_the_match, outcome_only=False):
     try:
-        # First load and process the latest users data
-        users_dict = load_and_process_users()
+        # Load current data
+        users_dict = load_users(USERS_JSON)
+        if not users_dict:
+            st.error("Failed to load users data")
+            return False
         
-        # Rest of your existing code for updating outcomes...
-        features = Features({
-            'match_id': Value('string'),
-            'man_of_the_match': Value('string'),
-            'winning_team': Value('string'),
-        })
-
         # Load existing match outcomes
         outcomes = load_dataset("Jay-Rajput/DIS_IPL_Outcomes", split="train")  
         outcomes_df = pd.DataFrame(outcomes)
@@ -552,18 +601,22 @@ def update_leaderboard_and_outcomes(match_id, winning_team, man_of_the_match, ou
                 user_data["last_5_results"].insert(0, result_indicator)
                 user_data["last_5_results"] = user_data["last_5_results"][:5]
 
-            # Save updated users data back to Hugging Face
-            users_dataset = Dataset.from_dict({k: [v] for k, v in users_dict.items()})
-            users_dataset.push_to_hub("Jay-Rajput/DIS_IPL_Leads")
+            # Save updated users data
+            if not safe_write_json(users_dict, USERS_JSON):
+                st.error("Failed to save updated users data")
+                return False
             
-            # Also save locally
-            with open(USERS_JSON, 'w', encoding='utf-8') as f:
-                json.dump(users_dict, f, ensure_ascii=False, indent=4)
+            # Push to Hugging Face
+            try:
+                users_dataset = Dataset.from_dict({k: [v] for k, v in users_dict.items()})
+                users_dataset.push_to_hub("Jay-Rajput/DIS_IPL_Leads")
+            except Exception as e:
+                st.error(f"Failed to update Hugging Face: {e}")
 
         # Save outcomes
         outcomes.to_json(OUTCOMES)
         outcomes.push_to_hub("Jay-Rajput/DIS_IPL_Outcomes", split="train")
-        
+        st.success("Match outcome submitted and leaderboard updated!")
         return True
     except Exception as e:
         st.error(f"Error updating leaderboard: {e}")
@@ -619,15 +672,19 @@ with st.sidebar:
                 outcome_only = expander.checkbox("Submit Outcome Only", key="outcome_only_checkbox")
 
                 if expander.button("Submit Match Outcome", key="submit_outcome"):
-                    if outcome_only:
-                        # Submit match outcome without updating user scores
-                        update_leaderboard_and_outcomes(selected_match_id, winning_team, man_of_the_match, outcome_only=True)
-                        expander.success("Match outcome submitted!")
-                    else:
-                        # Submit match outcome and update user scores
-                        update_leaderboard_and_outcomes(selected_match_id, winning_team, man_of_the_match)
-                        expander.success("Match outcome submitted and leaderboard updated!")
-                        st.experimental_rerun()
+                    with st.spinner("Processing match outcome..."):
+                        if update_leaderboard_and_outcomes(
+                            selected_match_id, 
+                            winning_team, 
+                            man_of_the_match, 
+                            outcome_only
+                        ):
+                            # Clear any previous errors
+                            st.success("Successfully updated match results and leaderboard!")
+                            # Force refresh the UI
+                            st.experimental_rerun()
+                        else:
+                            st.error("Failed to update match results")
             else:
                 expander.write("No matches available for the selected date.")
         else: