Goals wala integrate

db.py

@@ -80,6 +80,64 @@ def insert_sample_research_assistants():
 
 ###########
 
+###############
+# Add after research assistant schema
+
+# Analyst Schema
+analyst_schema = {
+    "bsonType": "object",
+    "required": ["full_name", "password", "email", "courses_analyzed"],
+    "properties": {
+        "full_name": {"bsonType": "string", "description": "Full name of the analyst"},
+        "password": {
+            "bsonType": "string",
+            "description": "Hashed password of the analyst",
+        },
+        "email": {"bsonType": "string", "description": "Email address of the analyst"},
+        "courses_analyzed": {
+            "bsonType": "array",
+            "description": "List of courses the analyst is analyzing",
+            "items": {
+                "bsonType": "object",
+                "required": ["course_id"],
+                "properties": {
+                    "course_id": {
+                        "bsonType": "string",
+                        "description": "ID of the course",
+                    }
+                },
+            },
+        },
+    },
+}
+
+# Create analysts collection
+analysts_collection = db["analysts"]
+
+# Create indexes for analysts
+analysts_collection.create_index("full_name", unique=True)
+analysts_collection.create_index("email", unique=True)
+
+
+def insert_sample_analysts():
+    sample_analysts = [
+        {
+            "full_name": "jane",
+            "password": generate_password_hash("jane"),
+            "email": "[email protected]",
+            "courses_analyzed": [{"course_id": "CS101"}, {"course_id": "CS102"}],
+        }
+    ]
+
+    try:
+        analysts_collection.insert_many(sample_analysts)
+        print("Sample analysts inserted successfully!")
+    except Exception as e:
+        print(f"Error inserting sample analysts: {e}")
+
+
+##############@
+
 
 # Define the course schema
 course_schema = {
@@ -635,4 +693,4 @@ research_assistants_collection.create_index("email", unique=True)
 #         print(f"Error inserting sample research assistants: {e}")
 
 # if __name__ == "__main__":
-#     insert_sample_research_assistants()
+#     insert_sample_analysts()

goals2.py

@@ -309,6 +309,181 @@ def display_analysis_results(analysis: Dict):
     st.metric("Relevance Score", f"{score}%")
 
 
+def display_analyst_dashboard():
+    st.title("Multi-Goal Document Analysis")
+
+    with st.sidebar:
+        st.markdown("### Input Section")
+        tab1, tab2 = st.tabs(["Document Analysis", "Similarity Search"])
+        # tab1, tab2 = st.tabs(["Document Analysis", "Similarity Search"])
+
+        with tab1:
+            # Multiple goals input
+            num_goals = st.number_input("Number of goals:", min_value=1, value=1)
+            goals = []
+            for i in range(num_goals):
+                goal = st.text_area(f"Goal {i+1}:", key=f"goal_{i}", height=100)
+                if goal:
+                    goals.append(goal)
+
+            uploaded_files = st.file_uploader(
+                "Upload documents",
+                accept_multiple_files=True,
+                type=["txt", "pdf", "docx"],
+            )
+            analyze_button = (
+                st.button("Analyze Documents") if goals and uploaded_files else None
+            )
+
+        with tab2:
+            # Keep existing similarity search tab
+            search_text = st.text_area("Enter text to find similar documents:")
+            search_limit = st.slider("Number of results", 1, 10, 5)
+            search_button = st.button("Search Similar") if search_text else None
+
+        if st.button("Logout", use_container_width=True):
+            for key in st.session_state.keys():
+                del st.session_state[key]
+            st.rerun()
+
+    if analyze_button:
+        analyzer = GoalAnalyzer()
+        vectorizer = DocumentVectorizer()
+
+        # Store vectors
+        doc_vectors = {}
+        goal_vectors = {}
+
+        # Process goals first
+        with st.spinner("Processing goals..."):
+            for i, goal in enumerate(goals):
+                vector = vectorizer.get_embedding(goal)
+                if vector:
+                    goal_vectors[f"Goal {i+1}"] = vector
+                    vectorizer.store_vector(f"Goal {i+1}", vector, goal, goal)
+
+        # Process documents
+        with st.spinner("Processing documents..."):
+            for file in uploaded_files:
+                st.markdown(f"### Analysis for {file.name}")
+
+                if vectorizer.vector_exists(file.name):
+                    st.info(f"Vector already exists for {file.name}")
+                    existing_doc = vectorizer.vectors_collection.find_one(
+                        {"name": file.name}
+                    )
+                    doc_vectors[file.name] = existing_doc["vector"]
+                else:
+                    text = analyzer.extract_text_from_file(file)
+                    if not text:
+                        st.warning(f"Could not extract text from {file.name}")
+                        continue
+
+                    vector = vectorizer.get_embedding(text)
+                    if vector:
+                        doc_vectors[file.name] = vector
+                        vectorizer.store_vector(file.name, vector, text)
+
+                # Display goal similarities
+                st.subheader("Goal Relevance Scores")
+                col1, col2 = st.columns([1, 2])
+
+                with col1:
+                    for goal_name, goal_vector in goal_vectors.items():
+                        similarity = (
+                            vectorizer.calculate_similarity(
+                                doc_vectors[file.name], goal_vector
+                            )
+                            * 100
+                        )
+                        st.metric(f"{goal_name}", f"{similarity:.1f}%")
+
+                with col2:
+                    # Get analysis for all goals combined
+                    analysis = asyncio.run(
+                        analyzer.get_perplexity_analysis(text, " | ".join(goals))
+                    )
+                    display_analysis_results(analysis)
+
+                st.divider()
+
+            # Document similarity matrix
+            if len(doc_vectors) > 1:
+                st.markdown("### Document Similarity Matrix")
+                files = list(doc_vectors.keys())
+                similarity_matrix = []
+
+                for file1 in files:
+                    row = []
+                    for file2 in files:
+                        similarity = vectorizer.calculate_similarity(
+                            doc_vectors[file1], doc_vectors[file2]
+                        )
+                        row.append(similarity)
+                    similarity_matrix.append(row)
+
+                df = pd.DataFrame(similarity_matrix, columns=files, index=files)
+                st.dataframe(df.style.background_gradient(cmap="RdYlGn"))
+
+                # Add goal-document similarity matrix
+                st.markdown("### Goal-Document Similarity Matrix")
+                goal_doc_matrix = []
+                goal_names = list(goal_vectors.keys())
+
+                for file in files:
+                    row = []
+                    for goal in goal_names:
+                        similarity = vectorizer.calculate_similarity(
+                            doc_vectors[file], goal_vectors[goal]
+                        )
+                        row.append(similarity)
+                    goal_doc_matrix.append(row)
+
+                df_goals = pd.DataFrame(
+                    goal_doc_matrix, columns=goal_names, index=files
+                )
+                st.dataframe(df_goals.style.background_gradient(cmap="RdYlGn"))
+
+    # Keep existing similarity search functionality
+    elif search_button:
+        vectorizer = DocumentVectorizer()
+        with st.spinner("Searching similar documents..."):
+            query_vector = vectorizer.get_embedding(search_text)
+            if query_vector:
+                similar_docs = vectorizer.vector_search(query_vector, search_limit)
+
+                if similar_docs:
+                    st.markdown("### Similar Documents Found")
+
+                    # Create DataFrame with numeric similarities
+                    df = pd.DataFrame(similar_docs)
+
+                    # Apply gradient to numeric column
+                    styled_df = df[["name", "similarity"]].style.background_gradient(
+                        cmap="RdYlGn", subset=["similarity"]
+                    )
+
+                    # Format display after styling
+                    styled_df = styled_df.format({"similarity": "{:.1%}"})
+
+                    st.dataframe(styled_df)
+
+                    # Show document contents
+                    for doc in similar_docs:
+                        with st.expander(
+                            f"📄 {doc['name']} (Similarity: {doc['similarity_display']})"
+                        ):
+                            st.text(
+                                doc["text"][:20] + "..."
+                                if len(doc["text"]) > 20
+                                else doc["text"]
+                            )
+                else:
+                    st.info("No similar documents found")
+            else:
+                st.error("Could not process search query")
+
+
 def main():
     st.title("Multi-Goal Document Analysis")
 

main.py

@@ -8,6 +8,7 @@ from db import (
     faculty_collection,
     students_collection,
     research_assistants_collection,
+    analysts_collection,
 )
 from werkzeug.security import generate_password_hash, check_password_hash
 import os
@@ -83,6 +84,8 @@ def login_user(username, password, user_type):
         user = faculty_collection.find_one({"full_name": username})
     elif user_type == "research_assistant":
         user = research_assistants_collection.find_one({"full_name": username})
+    elif user_type == "analyst":
+        user = analysts_collection.find_one({"full_name": username})
 
     if user and check_password_hash(user["password"], password):
         st.session_state.user_id = user["_id"]
@@ -99,7 +102,7 @@ def login_form():
 
     with st.form("login_form"):
         user_type = st.selectbox(
-            "Select User Type", ["student", "faculty", "research_assistant"]
+            "Select User Type", ["student", "faculty", "research_assistant", "analyst"]
         )
         username = st.text_input("Username")
         password = st.text_input("Password", type="password")
@@ -309,6 +312,97 @@ def get_new_course_id():
     return new_course_id
 
 
+# def register_page():
+#     st.title("Register")
+#     if "user_type" not in st.session_state:
+#         st.session_state.user_type = "student"
+
+#     # Select user type
+#     st.session_state.user_type = st.selectbox(
+#         "Select User Type", ["student", "faculty", "research_assistant"]
+#     )
+#     user_type = st.session_state.user_type
+#     print(user_type)
+
+#     with st.form("register_form"):
+#         # user_type = st.selectbox("Select User Type", ["student", "faculty", "research_assistant"])
+#         # print(user_type)
+#         full_name = st.text_input("Full Name")
+#         password = st.text_input("Password", type="password")
+#         confirm_password = st.text_input("Confirm Password", type="password")
+
+#         if user_type == "student":
+#             # Fetch courses for students to select from
+#             courses = list(courses_collection2.find({}, {"course_id": 1, "title": 1}))
+#             course_options = [
+#                 f"{course['title']} ({course['course_id']})" for course in courses
+#             ]
+#             selected_courses = st.multiselect("Available Courses", course_options)
+
+#         submit = st.form_submit_button("Register")
+
+#         if submit:
+#             if password == confirm_password:
+#                 hashed_password = generate_password_hash(password)
+#                 if user_type == "student":
+#                     new_student_id = get_new_student_id()
+#                     enrolled_courses = [
+#                         {
+#                             "course_id": course.split("(")[-1][:-1],
+#                             "title": course.split(" (")[0],
+#                         }
+#                         for course in selected_courses
+#                     ]
+#                     students_collection.insert_one(
+#                         {
+#                             "SID": new_student_id,
+#                             "full_name": full_name,
+#                             "password": hashed_password,
+#                             "enrolled_courses": enrolled_courses,
+#                             "created_at": datetime.utcnow(),
+#                         }
+#                     )
+#                     st.success(
+#                         f"Student registered successfully with ID: {new_student_id}"
+#                     )
+#                 elif user_type == "faculty":
+#                     new_faculty_id = get_new_faculty_id()
+#                     faculty_collection.insert_one(
+#                         {
+#                             "TID": new_faculty_id,
+#                             "full_name": full_name,
+#                             "password": hashed_password,
+#                             "courses_taught": [],
+#                             "created_at": datetime.utcnow(),
+#                         }
+#                     )
+#                     st.success(
+#                         f"Faculty registered successfully with ID: {new_faculty_id}"
+#                     )
+#                 elif user_type == "research_assistant":
+#                     research_assistants_collection.insert_one(
+#                         {
+#                             "full_name": full_name,
+#                             "password": hashed_password,
+#                             "created_at": datetime.utcnow(),
+#                         }
+#                     )
+#                     st.success("Research Assistant registered successfully!")
+#             else:
+#                 st.error("Passwords do not match")
+
+
+def get_new_analyst_id():
+    """Generate a new analyst ID by incrementing the last analyst ID"""
+    last_analyst = analysts_collection.find_one(sort=[("AID", -1)])
+    if last_analyst:
+        last_id = int(last_analyst["AID"][1:])
+        new_id = f"A{last_id + 1}"
+    else:
+        new_id = "A1"
+    return new_id
+
+
 def register_page():
     st.title("Register")
     if "user_type" not in st.session_state:
@@ -316,14 +410,12 @@ def register_page():
 
     # Select user type
     st.session_state.user_type = st.selectbox(
-        "Select User Type", ["student", "faculty", "research_assistant"]
+        "Select User Type", ["student", "faculty", "research_assistant", "analyst"]
     )
     user_type = st.session_state.user_type
     print(user_type)
 
     with st.form("register_form"):
-        # user_type = st.selectbox("Select User Type", ["student", "faculty", "research_assistant"])
-        # print(user_type)
         full_name = st.text_input("Full Name")
         password = st.text_input("Password", type="password")
         confirm_password = st.text_input("Confirm Password", type="password")
@@ -385,6 +477,17 @@ def register_page():
                         }
                     )
                     st.success("Research Assistant registered successfully!")
+                elif user_type == "analyst":
+                    # new_analyst_id = get_new_analyst_id()
+                    analysts_collection.insert_one(
+                        {
+                            # "AID": new_analyst_id,
+                            "full_name": full_name,
+                            "password": hashed_password,
+                            "created_at": datetime.utcnow(),
+                        }
+                    )
+                    st.success("Analyst registered successfully!")
             else:
                 st.error("Passwords do not match")
 
@@ -452,11 +555,14 @@ def create_course_form(faculty_name, faculty_id):
 
 from research_assistant_dashboard import display_research_assistant_dashboard
 
+from goals2 import display_analyst_dashboard
+
 
 def main_dashboard():
     if st.session_state.user_type == "research_assistant":
         display_research_assistant_dashboard()
-
+    elif st.session_state.user_type == "analyst":
+        display_analyst_dashboard()
     else:
         selected_course_id = None
         create_session = False
@@ -473,8 +579,10 @@ def main_dashboard():
             )
 
             if st.session_state.user_type == "faculty":
-                if st.button("Create New Course", key="create_course", use_container_width=True):
-                        st.session_state.show_create_course_form = True
+                if st.button(
+                    "Create New Course", key="create_course", use_container_width=True
+                ):
+                    st.session_state.show_create_course_form = True
 
             if not enrolled_courses:
                 st.warning("No courses found")
@@ -538,6 +646,7 @@ def main_dashboard():
         # if create_session:
         #     create_session_form(selected_course_id)
 
+
 def main():
     st.set_page_config(page_title="NOVAScholar", page_icon="📚", layout="wide")
     init_session_state()