Update app.py

app.py

@@ -1,94 +1,108 @@
-import streamlit as st # This imports the streamlit module for creating the UI
-import google.generativeai as genai # This imports the google generative AI module for using the model
-import sqlite3 # This imports the sqlite3 module for working with the database
+import streamlit as st
+import google.generativeai as genai
+import sqlite3
 from streamlit import file_uploader
 
 # Database setup
-conn = sqlite3.connect('chat_history.db') # This creates a connection to the chat_history.db file
-c = conn.cursor() # This creates a cursor object to execute SQL commands
+conn = sqlite3.connect('chat_history.db') 
+c = conn.cursor() 
 
 c.execute('''
           CREATE TABLE IF NOT EXISTS history  
           (role TEXT, message TEXT)  
-          ''') # This creates a table named history with two columns: role and message
-          
-# Generative AI setup          
-api_key = "AIzaSyC70u1sN87IkoxOoIj4XCAPw97ae2LZwNM" # This is where you put your API key for the generative AI service
-genai.configure(api_key=api_key) # This configures the genai module with your API key
+          ''')
+
+# Generative AI setup
+api_key = "YOUR_API_KEY" 
+genai.configure(api_key=api_key)
 
 generation_config = {
-  "temperature": 0.9, # This is a parameter that controls the randomness of the generated text
-  "max_output_tokens": 500 # This is a parameter that limits the maximum number of tokens in the generated text
+  "temperature": 0.9,
+  "max_output_tokens": 500 
 }
 
-safety_settings = [] # This is a list of safety settings that can filter out harmful or inappropriate content
+safety_settings = [] 
 
 # Streamlit UI
-st.title("Chatbot") # This displays a title for the UI
+st.title("Chatbot") 
 
-chat_history = st.session_state.get("chat_history", []) # This gets the chat history from the session state or creates an empty list
+chat_history = st.session_state.get("chat_history", [])
 
-if len(chat_history) % 2 == 0: # This checks if the chat history has an even number of messages
-  role = "user" # This sets the role to user
+if len(chat_history) % 2 == 0: 
+  role = "user" 
 else:  
-  role = "model" # This sets the role to model
-  
-for message in chat_history: # This loops through each message in the chat history
-  r, t = message["role"], message["parts"][0]["text"] # This extracts the role and the text from the message
-  st.markdown(f"**{r.title()}:** {t}") # This displays the role and the text in markdown format
-  
-user_input = st.text_input("") # This creates a text input widget for the user
+  role = "model"
+
+for message in chat_history: 
+  r, t = message["role"], message["parts"][0]["text"] 
+  st.markdown(f"**{r.title()}:** {t}") 
+
+user_input = st.text_input("") 
 
 # File uploader for images
-uploaded_file = st.file_uploader("Upload an image (optional)") # This creates a file uploader widget for the user to upload an image file
-
-if user_input: # This checks if the user has entered some text
-  chat_history.append({"role": role, "parts": [{"text": user_input}]}) # This appends the user input to the chat history
-  
-  if role == "user": # This checks if the role is user
-    # Check if an image is uploaded
-    image_parts = [] # This creates an empty list for the image parts
-    if uploaded_file: # This checks if the user has uploaded a file
-      image_parts.append({ # This appends a dictionary with the image information to the image parts list
-        "mime_type": uploaded_file.type, # This gets the mime type of the file
-        "data": uploaded_file.read() # This reads the bytes of the file
-      })
-    
-    # Choose the model name based on the image parts
-    if image_parts: # This checks if the image parts list is not empty
-      model_name = "gemini-pro-vision" # This sets the model name to gemini-pro-vision
-    else:
-      model_name = "gemini-pro" # This sets the model name to gemini-pro
-
-    # Create the generative model object
+uploaded_file = st.file_uploader("Upload an image (optional)")
+
+if user_input: 
+  chat_history.append({"role": role, "parts": [{"text": user_input}]})
+
+  if role == "user": 
+    # If only text is entered, follow the previous code
+    model_name = "gemini-pro"
+
     model = genai.GenerativeModel(
-      model_name=model_name, # This passes the model name to the model object
-      generation_config=generation_config, # This passes the generation config to the model object
-      safety_settings=safety_settings # This passes the safety settings to the model object
+      model_name=model_name,
+      generation_config=generation_config,
+      safety_settings=safety_settings
     )
-    
-    # Generate response based on text and image
-    response = model.generate_content(chat_history + image_parts) # This generates a response from the model based on the chat history and the image parts
-    response_text = response.text # This gets the text of the response
-    chat_history.append({"role": "model", "parts": [{"text": response_text}]}) # This appends the response text to the chat history
-    
-  st.session_state["chat_history"] = chat_history # This updates the session state with the chat history
-
-  for message in chat_history: # This loops through each message in the chat history
-    r, t = message["role"], message["parts"][0]["text"] # This extracts the role and the text from the message
-    st.markdown(f"**{r.title()}:** {t}") # This displays the role and the text in markdown format
-
-if st.button("Display History"): # This creates a button widget for displaying the history
-    c.execute("SELECT * FROM history") # This executes a SQL command to select all the rows from the history table
-    rows = c.fetchall() # This fetches all the rows from the cursor object
-
-    for row in rows: # This loops through each row in the rows list
-        st.markdown(f"**{row[0].title()}:** {row[1]}") # This displays the role and the message in markdown format
+
+    response = model.generate_content(chat_history)
+    response_text = response.text 
+    chat_history.append({"role": "model", "parts": [{"text": response_text}]}) 
+
+  st.session_state["chat_history"] = chat_history 
+
+  for message in chat_history: 
+    r, t = message["role"], message["parts"][0]["text"] 
+    st.markdown(f"**{r.title()}:** {t}") 
+
+if st.button("Display History"): 
+    c.execute("SELECT * FROM history") 
+    rows = c.fetchall() 
+
+    for row in rows: 
+        st.markdown(f"**{row[0].title()}:** {row[1]}") 
         
 # Save chat history to database
-for message in chat_history: # This loops through each message in the chat history
+for message in chat_history: 
     c.execute("INSERT INTO history VALUES (?, ?)", 
-            (message["role"], message["parts"][0]["text"])) # This executes a SQL command to insert the role and the message into the history table
-    conn.commit() # This commits the changes to the database
+            (message["role"], message["parts"][0]["text"])) 
+    conn.commit() 
+
+conn.close()
+
+# Separate section for image uploading
+st.title("Image Description Generator")
+
+uploaded_file = st.file_uploader("Upload an image here", type=["png", "jpg", "jpeg"])
+
+if uploaded_file:
+   image_parts = [
+     {
+       "mime_type": uploaded_file.type,
+       "data": uploaded_file.read() 
+     },
+   ]
+
+   prompt_parts = [
+     "Describe the image:",
+     image_parts[0],
+   ]
 
-conn.close() # This closes the connection to the database
+   model = genai.GenerativeModel(
+     model_name="gemini-pro-vision", 
+     generation_config=generation_config, 
+     safety_settings=safety_settings 
+   )
+   
+   response = model.generate_content(prompt_parts)
+   st.markdown(f"**Model's description:** {response.text}")