Update app.py

app.py

@@ -1,4 +1,6 @@
 import streamlit as st
+from pathlib import Path # Ensure Path is imported if used for settings.LOGO_PATH
+
 from config.settings import settings
 from models import create_db_and_tables, get_session_context, User, ChatMessage, ChatSession
 from models.user import UserCreate # For type hinting
@@ -10,7 +12,7 @@ from services.logger import app_logger
 # --- Page Configuration ---
 st.set_page_config(
     page_title=settings.APP_TITLE,
-    page_icon="⚕️", # You can use an emoji or a path to an image
+    page_icon="⚕️",
     layout="wide",
     initial_sidebar_state="expanded"
 )
@@ -26,7 +28,7 @@ init_db()
 
 # --- Session State Initialization ---
 if 'authenticated_user' not in st.session_state:
-    st.session_state.authenticated_user = None # Stores User object upon successful login
+    st.session_state.authenticated_user = None # Stores User object (ideally one that is "live" or has loaded attributes)
 if 'current_chat_session_id' not in st.session_state:
     st.session_state.current_chat_session_id = None
 if 'chat_messages' not in st.session_state: # For the current active chat
@@ -37,59 +39,76 @@ if 'chat_messages' not in st.session_state: # For the current active chat
 def display_login_form():
     with st.form("login_form"):
         st.subheader("Login")
-        username_input = st.text_input("Username", key="login_username_input") # Added key for clarity
-        password_input = st.text_input("Password", type="password", key="login_password_input") # Added key
+        # Use unique keys for inputs if there's any chance of collision or for better state tracking
+        username_input = st.text_input("Username", key="login_username_input")
+        password_input = st.text_input("Password", type="password", key="login_password_input")
         submit_button = st.form_submit_button("Login")
 
         if submit_button:
-            # IMPORTANT: The 'user' object returned by authenticate_user needs to have
-            # its essential attributes (like id, username) already loaded, or if its session
-            # was closed, those attributes should not be in an "expired" state that requires
-            # a database refresh. Typically, a query like db.query(User)...first() loads these.
-            # If authenticate_user involves a commit and session.expire_on_commit=True (default),
-            # it should call db.refresh(user_object) before closing its session and returning.
-            user = authenticate_user(username_input, password_input)
-            if user:
-                st.session_state.authenticated_user = user
-                # Accessing user.username and user.id here.
-                # If 'user' is detached and attributes are expired, this could also fail.
-                # This implies authenticate_user should return a "usable" object.
-                st.success(f"Welcome back, {user.username}!")
+            # IMPORTANT: 'authenticate_user' should return a User object where essential attributes
+            # like 'id' and 'username' are already loaded (not expired).
+            # If 'authenticate_user' involves a commit (e.g., updating last_login) and
+            # session.expire_on_commit=True (default), it should call db.refresh(user_object)
+            # before closing its session and returning the user object.
+            user_from_auth = authenticate_user(username_input, password_input)
+
+            if user_from_auth:
+                # FIX 1: For the success message, use the 'username_input' from the form directly.
+                # This avoids accessing 'user_from_auth.username' which might be on a detached/expired instance.
+                st.success(f"Welcome back, {username_input}!")
+                app_logger.info(f"User {username_input} logged in successfully.")
+
                 try:
                     with get_session_context() as db_session:
-                        # Ensure the user object is attached to the current session if needed,
-                        # or that its ID is accessible even if detached.
-                        # user_id = user.id (if user.id is loaded, this is fine)
-                        # live_user = db_session.merge(user) # if user might be detached but has PK
-                        # Or better if only ID is needed:
-                        live_user = db_session.get(User, user.id) # Re-fetch/attach to current session
+                        # FIX 2: Re-fetch or merge the user into the current db_session to ensure it's "live"
+                        # This assumes 'user_from_auth.id' is accessible (i.e., was loaded by authenticate_user).
+                        # If 'user_from_auth.id' itself is expired, 'authenticate_user' MUST be fixed.
+                        try:
+                            user_id = user_from_auth.id
+                        except AttributeError:
+                            st.error("Authentication error: User data is incomplete. Please try again.")
+                            app_logger.error(f"User object from authenticate_user for '{username_input}' lacks 'id' attribute or it's inaccessible.")
+                            st.session_state.authenticated_user = None # Clear potentially bad state
+                            st.rerun()
+                            return
+
+                        live_user = db_session.get(User, user_id)
                         if not live_user:
-                            st.error("User session error. Please log in again.")
-                            app_logger.error(f"Failed to re-fetch user with id {user.id} in new session.")
+                            st.error("Critical user session error. Please log out and log in again.")
+                            app_logger.error(f"Failed to re-fetch user with id {user_id} (username: {username_input}) in new session.")
                             st.session_state.authenticated_user = None # Clear broken state
                             st.rerun()
                             return
 
+                        # Store the "live" user object (attached to db_session or with loaded attributes)
+                        # in session_state. This 'live_user' will be used by the sidebar.
+                        st.session_state.authenticated_user = live_user
+
+                        # Now use 'live_user' for creating the chat session
                         new_chat_session = ChatSession(user_id=live_user.id, title=f"Session for {live_user.username}")
                         db_session.add(new_chat_session)
                         db_session.commit()
-                        db_session.refresh(new_chat_session) # Refresh new_chat_session
+                        db_session.refresh(new_chat_session) # Refresh to get DB-generated values for new_chat_session
                         st.session_state.current_chat_session_id = new_chat_session.id
                         st.session_state.chat_messages = [] # Clear previous messages
-                    st.rerun() # Rerun to reflect login state
+                    st.rerun() # Rerun to reflect login state and navigate
                 except Exception as e:
-                    app_logger.error(f"Error creating chat session for user {user.username}: {e}")
+                    app_logger.error(f"Error creating chat session for user {username_input}: {e}", exc_info=True)
                     st.error(f"Could not start a new session: {e}")
+                    # Optionally, clear authenticated_user if session creation is critical
+                    # st.session_state.authenticated_user = None
+                    # st.rerun()
             else:
                 st.error("Invalid username or password.")
+                app_logger.warning(f"Failed login attempt for username: {username_input}")
 
 def display_signup_form():
     with st.form("signup_form"):
         st.subheader("Sign Up")
-        new_username = st.text_input("Choose a Username", key="signup_username_input") # Added key
-        new_email = st.text_input("Email (Optional)", key="signup_email_input") # Added key
-        new_password = st.text_input("Choose a Password", type="password", key="signup_password_input") # Added key
-        confirm_password = st.text_input("Confirm Password", type="password", key="signup_confirm_password_input") # Added key
+        new_username = st.text_input("Choose a Username", key="signup_username_input")
+        new_email = st.text_input("Email (Optional)", key="signup_email_input")
+        new_password = st.text_input("Choose a Password", type="password", key="signup_password_input")
+        confirm_password = st.text_input("Confirm Password", type="password", key="signup_confirm_password_input")
         submit_button = st.form_submit_button("Sign Up")
 
         if submit_button:
@@ -103,40 +122,21 @@ def display_signup_form():
                     password=new_password,
                     email=new_email if new_email else None
                 )
-                # --- Explanation of the DetachedInstanceError and its handling ---
-                # The 'create_user_in_db' function creates a User and commits it to the database.
-                # If the SQLAlchemy session used inside 'create_user_in_db' has 'expire_on_commit=True'
-                # (which is the default), all attributes of the 'user' object are marked as "expired"
-                # after the commit.
-                # If 'create_user_in_db' then closes its session and returns this 'user' object,
-                # the object becomes "detached".
-                # When you later try to access an expired attribute (like 'user.username'),
-                # SQLAlchemy attempts to reload it from the database. Since the object is detached
-                # (not bound to an active session), this reload fails, raising DetachedInstanceError.
-
-                # TO FIX ROBUSTLY (in services/auth.py, inside create_user_in_db):
-                # After `db_session.commit()`, ensure `db_session.refresh(created_user_object)` is called
-                # *before* the session is closed and the object is returned. This loads all attributes
-                # from the database, so they are no longer "expired".
-
+                # 'create_user_in_db' should return a User object with attributes loaded
+                # (e.g., by calling session.refresh(user) before its session closes).
                 user = create_user_in_db(user_data)
                 if user:
-                    # IMMEDIATE FIX for this specific line:
-                    # Instead of 'user.username' (which might be on a detached, expired instance),
-                    # use 'new_username', which is the value just submitted by the user and
-                    # used for creation. This avoids the need to access the potentially problematic 'user' object attribute.
+                    # Use 'new_username' (from form input) for the message to avoid DetachedInstanceError
                     st.success(f"Account created for {new_username}. Please log in.")
                     app_logger.info(f"Account created for {new_username}.")
-
-                    # If you were to enable direct login here:
-                    # st.session_state.authenticated_user = user
-                    # st.rerun()
-                    # ...then it becomes CRITICAL that 'create_user_in_db' returns a 'user' object
-                    # whose attributes (like .id, .username) are already loaded and not expired,
-                    # as explained in the "TO FIX ROBUSTLY" comment above.
+                    # Optionally log them in directly:
+                    # To do this safely, 'user' returned by create_user_in_db must be "live"
+                    # or its attributes fully loaded. You might need to re-fetch it in a new session here
+                    # if you intend to store it in st.session_state.authenticated_user.
+                    # For now, redirecting to login is simpler.
                 else:
-                    st.error("Username might already be taken or another error occurred during signup.")
-                    app_logger.warning(f"Failed to create user for username: {new_username}")
+                    st.error("Username might already be taken or an error occurred during signup.")
+                    app_logger.warning(f"Signup failed for username: {new_username}")
 
 # --- Main App Logic ---
 if not st.session_state.authenticated_user:
@@ -149,52 +149,50 @@ if not st.session_state.authenticated_user:
     with signup_tab:
         display_signup_form()
 else:
-    # If authenticated, Streamlit automatically navigates to pages in the `pages/` directory.
-    # The content of `app.py` typically acts as the "Home" page if no `1_Home.py` exists,
-    # or it can be used for global elements like a custom sidebar if not using Streamlit's default page navigation.
-
-    # Custom Sidebar for logged-in users
+    # If authenticated
     with st.sidebar:
-        # Ensure authenticated_user object is usable. If it was detached with expired attributes
-        # upon login, this access could also fail. This reinforces the need for authenticate_user
-        # to return a "live" or fully-loaded object.
+        # Accessing st.session_state.authenticated_user.username.
+        # This relies on the object stored in authenticated_user having its username loaded.
+        # The `display_login_form` now stores the 'live_user' which should have this.
         try:
             st.markdown(f"### Welcome, {st.session_state.authenticated_user.username}!")
-        except AttributeError: # Fallback if username is not accessible
+        except AttributeError as e: # Fallback if username somehow isn't accessible
              st.markdown(f"### Welcome!")
-             app_logger.error("Could not access username for authenticated_user in sidebar.")
+             app_logger.error(f"Could not access username for authenticated_user in sidebar: {e}. User object: {st.session_state.authenticated_user}")
+
 
-        if st.session_state.get("SHOW_LOGO_IN_SIDEBAR", True) and settings.LOGO_PATH and Path(settings.LOGO_PATH).exists(): # Example for conditional logo
-            try:
-                st.image(settings.LOGO_PATH, width=100)
-            except Exception as e:
-                app_logger.warning(f"Could not load logo from {settings.LOGO_PATH}: {e}")
+        # Example for conditional logo display
+        logo_path_str = getattr(settings, "LOGO_PATH", None)
+        if logo_path_str:
+            logo_path = Path(logo_path_str)
+            if logo_path.exists():
+                try:
+                    st.image(str(logo_path), width=100)
+                except Exception as e:
+                    app_logger.warning(f"Could not load logo from {logo_path_str}: {e}")
+            else:
+                app_logger.warning(f"Logo path specified but does not exist: {logo_path_str}")
         elif settings.APP_TITLE: # Fallback to title if no logo
              st.markdown(f"#### {settings.APP_TITLE}")
 
-
         st.markdown("---")
 
         if st.button("Logout"):
-            app_logger.info(f"User {st.session_state.authenticated_user.username} logging out.")
+            if hasattr(st.session_state.authenticated_user, 'username'):
+                app_logger.info(f"User {st.session_state.authenticated_user.username} logging out.")
+            else:
+                app_logger.info("User logging out (username not accessible from session state object).")
             st.session_state.authenticated_user = None
             st.session_state.current_chat_session_id = None
             st.session_state.chat_messages = []
             st.success("You have been logged out.")
             st.rerun()
 
-    # This content will show if no other page is selected, or if you don't have a 1_Home.py
-    # If you have 1_Home.py, Streamlit will show that by default after login.
-    st.sidebar.success("Select a page above to get started.") # Or from the main area below if multi-page app
-
-    # Main area content (could be your "Home" page)
+    # Main area content (could be your "Home" page if no `pages/1_Home.py`)
+    st.sidebar.success("Select a page from the navigation.") # More generic message
     st.header(f"Dashboard - {settings.APP_TITLE}")
     st.markdown("Navigate using the sidebar to consult with the AI or view your reports.")
     st.markdown("---")
-    st.info("This is the main application area. If you see this, ensure you have a `pages/1_Home.py` or that this `app.py` is your intended landing page after login.")
-
-
-# Ensure Path is imported if used for logo
-from pathlib import Path
+    st.info("This is the main application area. If you have pages in a `pages/` directory, Streamlit will show the selected page here. Otherwise, this content is shown.")
 
 app_logger.info(f"Streamlit app '{settings.APP_TITLE}' initialized and running.")