Update app.py

app.py

@@ -1,7 +1,7 @@
 import os
 import streamlit as st
 import firebase_admin
-from firebase_admin import credentials, db, auth, firestore
+from firebase_admin import credentials, auth, firestore, db as realtimedb
 import face_recognition
 from PIL import Image
 import numpy as np
@@ -12,18 +12,22 @@ import dlib
 current_directory = os.path.dirname(os.path.abspath(__file__))
 skp_path = os.path.join(current_directory, "projectinsta-s-firebase-adminsdk-y6vlu-9a1345f468.json")
 
-# Check if the app is already initialized
+# Initialize Firebase Admin SDK for Firestore
 if not firebase_admin._apps:
-    # Initialize Firebase Admin SDK
     cred = credentials.Certificate(skp_path)
     firebase_admin.initialize_app(cred, {
         'databaseURL': 'https://projectinsta-s-default-rtdb.firebaseio.com/',
         'projectId': 'projectinsta-s'
     })
-    db = firestore.client()
+    db_firestore = firestore.client()
 
-# Reference to the root of your Firebase Realtime Database
-ref = db.reference('/')
+# Initialize Firebase Admin SDK for Realtime Database
+if not firebase_admin._apps:
+    cred = credentials.Certificate(skp_path)
+    firebase_admin.initialize_app(cred, {
+        'projectId': 'projectinsta-s'
+    })
+    db_realtime = realtimedb.reference()
 
 # Streamlit session state
 if "auth_state" not in st.session_state:
@@ -62,28 +66,48 @@ def create_user(email, password):
 # Function to send a message
 def send_message(sender, recipient, message):
     try:
-        # Add a new document with a generated ID
-        db.collection("messages").add({
+        # Add a new document with a generated ID to Firestore
+        db_firestore.collection("messages").add({
             "sender": sender,
             "recipient": recipient,
             "message": message,
             "timestamp": firebase_admin.firestore.SERVER_TIMESTAMP
         })
+        
+        # Add a new child with a generated ID to Realtime Database
+        db_realtime.child("messages").push({
+            "sender": sender,
+            "recipient": recipient,
+            "message": message,
+            "timestamp": firebase_admin.firestore.SERVER_TIMESTAMP
+        })
+
         return "Message sent successfully!"
     except Exception as e:
         return f"Failed to send message: {str(e)}"
 
-# Function to retrieve messages
-def retrieve_messages():
+# Function to retrieve messages from Firestore
+def retrieve_messages_firestore():
     try:
-        # Retrieve all documents from the 'messages' collection
-        messages_ref = db.collection("messages").order_by("timestamp")
+        # Retrieve all documents from the 'messages' collection in Firestore
+        messages_ref = db_firestore.collection("messages").order_by("timestamp")
         for message in messages_ref.stream():
             message_data = message.to_dict()
             # Display the message in the chat interface
             st.write(f"{message_data['sender']}: {message_data['message']} ({message_data['timestamp']})")
     except Exception as e:
-        st.error(f"Failed to retrieve messages: {str(e)}")
+        st.error(f"Failed to retrieve messages from Firestore: {str(e)}")
+
+# Function to retrieve messages from Realtime Database
+def retrieve_messages_realtime():
+    try:
+        # Retrieve all documents from the 'messages' collection in Realtime Database
+        messages_ref = db_realtime.child("messages").get()
+        for message_id, message_data in messages_ref.items():
+            # Display the message in the chat interface
+            st.write(f"{message_data['sender']}: {message_data['message']} ({message_data['timestamp']})")
+    except Exception as e:
+        st.error(f"Failed to retrieve messages from Realtime Database: {str(e)}")
         
 # Update load_and_encode function to use the aligned face without normalization
 def load_and_encode(image_path):
@@ -140,8 +164,8 @@ def add_person(name, image_path, instagram_handle):
         # Convert NumPy arrays to lists for JSON serialization
         encoding = encoding[0].tolist()
 
-        # Save data to Firebase Realtime Database
-        ref.child(name).set({
+        # Save data to Firestore
+        db_firestore.collection("persons").document(name).set({
             "encoding": encoding,
             "info": {
                 "instagram_handle": instagram_handle,
@@ -149,9 +173,9 @@ def add_person(name, image_path, instagram_handle):
             }
         })
 
-        return f"Success: {name} added to the database!"
+        return f"Success: {name} added to Firestore!"
     except Exception as e:
-        return f"Failed to add person: {str(e)}"
+        return f"Failed to add person to Firestore: {str(e)}"
 
 # Recognize face from image
 def recognize_face(image_path):
@@ -164,10 +188,11 @@ def recognize_face(image_path):
             return "No face found in the provided image."
 
         matches = []
-        for name, data in ref.get().items():
+        for person_ref in db_firestore.collection("persons").stream():
+            data = person_ref.to_dict()
             known_encoding = np.array(data["encoding"])
             if face_recognition.compare_faces([known_encoding], unknown_encoding[0])[0]:
-                matches.append((name, data["info"]))
+                matches.append((person_ref.id, data["info"]))
 
         if matches:
             results = []
@@ -193,15 +218,16 @@ def recognize_face_optimal(image_path):
             return "No face found in the provided image."
 
         matches = []
-        for name, data in ref.get().items():
+        for person_ref in db_firestore.collection("persons").stream():
+            data = person_ref.to_dict()
             known_encoding = np.array(data["encoding"])
             similarity_score = face_recognition.face_distance([known_encoding], unknown_encoding[0])[0]
-            matches.append((name, similarity_score))
+            matches.append((person_ref.id, similarity_score))
 
         if matches:
             best_match = min(matches, key=lambda x: x[1])
             best_name, best_score = best_match
-            info = ref.child(best_name).child("info").get()
+            info = db_firestore.collection("persons").document(best_name).get().to_dict()["info"]
             insta_handle = info["instagram_handle"]
             insta_link = info["instagram_link"]
             insta_link_html = f'<a href="{insta_link}" target="_blank"><font color="red">{insta_handle}</font></a>'
@@ -211,13 +237,13 @@ def recognize_face_optimal(image_path):
     except Exception as e:
         return f"Failed to recognize face: {str(e)}"
 
-# Delete person from database
+# Delete person from Firestore
 def delete_person(name):
     try:
-        ref.child(name).delete()
-        return f"{name} deleted from the database!"
+        db_firestore.collection("persons").document(name).delete()
+        return f"{name} deleted from Firestore!"
     except Exception as e:
-        return f"Failed to delete person: {str(e)}"
+        return f"Failed to delete person from Firestore: {str(e)}"
 
 # Streamlit interface for adding a person
 def add_person_ui():
@@ -240,7 +266,7 @@ def recognize_face_ui():
         result = recognize_face(image_path)
         st.write(result, unsafe_allow_html=True)
 
-# Streamlit interface for chat
+# Streamlit interface for chat (Retrieve messages from both Firestore and Realtime Database)
 def chat_ui():
     st.title("Chat")
     sender = st.session_state.auth_state["user"]["email"]
@@ -249,8 +275,10 @@ def chat_ui():
     if st.button("Send"):
         result = send_message(sender, recipient, message)
         st.write(result)
-    st.header("Messages")
-    retrieve_messages()
+    st.header("Messages (Firestore)")
+    retrieve_messages_firestore()
+    st.header("Messages (Realtime Database)")
+    retrieve_messages_realtime()
 
 # Streamlit interface for recognizing face with optimal ID
 def recognize_face_optimal_ui():