Update app.py

app.py

@@ -1,280 +1,106 @@
-import os
-import time
-import uuid
-from typing import List, Tuple, Optional, Dict, Union
-
-import google.generativeai as genai
 import streamlit as st
-from PIL import Image
-
-print("google-generativeai:", genai.__version__)
-
-GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
-
-TITLE = """<h1 align="center">Gemini Playground 💬</h1>"""
-SUBTITLE = """<h2 align="center">Play with Gemini Pro and Gemini Pro Vision API</h2>"""
-DUPLICATE = """
-<div style="text-align: center; display: flex; justify-content: center; align-items: center;">
-    <a href="https://huggingface.co/spaces/SkalskiP/ChatGemini?duplicate=true">
-        <img src="https://bit.ly/3gLdBN6" alt="Duplicate Space" style="margin-right: 10px;">
-    </a>
-    <span>Duplicate the Space and run securely with your 
-        <a href="https://makersuite.google.com/app/apikey">GOOGLE API KEY</a>.
-    </span>
-</div>
-"""
-
-AVATAR_IMAGES = (
-    None,
-    "https://media.roboflow.com/spaces/gemini-icon.png"
-)
-
-IMAGE_CACHE_DIRECTORY = "/tmp"
-IMAGE_WIDTH = 512
-CHAT_HISTORY = List[List[Optional[Union[Tuple[str], str]], Optional[str]]]
-
-
-def preprocess_stop_sequences(stop_sequences: str) -> Optional[List[str]]:
-    if not stop_sequences:
-        return None
-    return [sequence.strip() for sequence in stop_sequences.split(",")]
-
-
-def preprocess_image(image: Image.Image) -> Optional[Image.Image]:
-    image_height = int(image.height * IMAGE_WIDTH / image.width)
-    return image.resize((IMAGE_WIDTH, image_height))
-
-
-def cache_pil_image(image: Image.Image) -> str:
-    image_filename = f"{uuid.uuid4()}.jpeg"
-    os.makedirs(IMAGE_CACHE_DIRECTORY, exist_ok=True)
-    image_path = os.path.join(IMAGE_CACHE_DIRECTORY, image_filename)
-    image.save(image_path, "JPEG")
-    return image_path
-
-
-def preprocess_chat_history(
-    history: CHAT_HISTORY
-) -> List[Dict[str, Union[str, List[str]]]]:
-    messages = []
-    for user_message, model_message in history:
-        if isinstance(user_message, tuple):
-            pass
-        elif user_message is not None:
-            messages.append({'role': 'user', 'parts': [user_message]})
-        if model_message is not None:
-            messages.append({'role': 'model', 'parts': [model_message]})
-    return messages
-
-
-def upload(files: Optional[List[str]], chatbot: CHAT_HISTORY) -> CHAT_HISTORY:
-    for file in files:
-        image = Image.open(file).convert('RGB')
-        image = preprocess_image(image)
-        image_path = cache_pil_image(image)
-        chatbot.append(((image_path,), None))
-    return chatbot
-
-
-def user(text_prompt: str, chatbot: CHAT_HISTORY):
-    if text_prompt:
-        chatbot.append((text_prompt, None))
-    return "", chatbot
-
-
-def bot(
-    google_key: str,
-    files: Optional[List[str]],
-    temperature: float,
-    max_output_tokens: int,
-    stop_sequences: str,
-    top_k: int,
-    top_p: float,
-    chatbot: CHAT_HISTORY
-):
-    if len(chatbot) == 0:
-        return chatbot
+import google.generativeai as genai
+import sqlite3 
+from streamlit import file_uploader
 
-    google_key = google_key if google_key else GOOGLE_API_KEY
-    if not google_key:
-        raise ValueError(
-            "GOOGLE_API_KEY is not set. "
-            "Please follow the instructions in the README to set it up.")
+# Database setup
+conn = sqlite3.connect('chat_history.db')  
+c = conn.cursor()
 
-    genai.configure(api_key=google_key)
-    generation_config = genai.types.GenerationConfig(
-        temperature=temperature,
-        max_output_tokens=max_output_tokens,
-        stop_sequences=preprocess_stop_sequences(stop_sequences=stop_sequences),
-        top_k=top_k,
-        top_p=top_p)
+c.execute('''
+          CREATE TABLE IF NOT EXISTS history  
+          (role TEXT, message TEXT)
+          ''')
 
-    if files:
-        text_prompt = [chatbot[-1][0]] \
-            if chatbot[-1][0] and isinstance(chatbot[-1][0], str) \
-            else []
-        image_prompt = [Image.open(file).convert('RGB') for file in files]
-        model = genai.GenerativeModel('gemini-pro-vision')
-        response = model.generate_content(
-            text_prompt + image_prompt,
-            stream=True,
-            generation_config=generation_config)
-    else:
-        messages = preprocess_chat_history(chatbot)
-        model = genai.GenerativeModel('gemini-pro')
-        response = model.generate_content(
-            messages,
-            stream=True,
-            generation_config=generation_config)
+# Generative AI setup
+api_key = "AIzaSyC70u1sN87IkoxOoIj4XCAPw97ae2LZwNM"   
+genai.configure(api_key=api_key)
 
-    # streaming effect
-    chatbot[-1][1] = ""
-    for chunk in response:
-        for i in range(0, len(chunk.text), 10):
-            section = chunk.text[i:i + 10]
-            chatbot[-1][1] += section
-            time.sleep(0.01)
-            yield chatbot
+generation_config = {
+  "temperature": 0.9,
+  "max_output_tokens": 3000  
+}
 
+safety_settings = []
 
 # Streamlit UI
-st.markdown(TITLE, unsafe_allow_html=True)
-st.markdown(SUBTITLE, unsafe_allow_html=True)
-st.markdown(DUPLICATE, unsafe_allow_html=True)
+st.title("Chatbot")
 
-# Sidebar for parameters
-st.sidebar.header("Parameters")
-google_key = st.sidebar.text_input(
-    label="GOOGLE API KEY",
-    value="",
-    type="password",
-    help="You have to provide your own GOOGLE_API_KEY for this app to function properly",
-    key="google_key"
-)
-temperature = st.sidebar.slider(
-    label="Temperature",
-    min_value=0.0,
-    max_value=1.0,
-    value=0.4,
-    step=0.05,
-    help=(
-        "Temperature controls the degree of randomness in token selection. Lower "
-        "temperatures are good for prompts that expect a true or correct response, "
-        "while higher temperatures can lead to more diverse or unexpected results. "
-    ),
-    key="temperature"
-)
-max_output_tokens = st.sidebar.slider(
-    label="Token limit",
-    min_value=1,
-    max_value=2048,
-    value=1024,
-    step=1,
-    help=(
-        "Token limit determines the maximum amount of text output from one prompt. A "
-        "token is approximately four characters. The default value is 2048."
-    ),
-    key="max_output_tokens"
-)
-stop_sequences = st.sidebar.text_input(
-    label="Add stop sequence",
-    value="",
-    help=(
-        "A stop sequence is a series of characters (including spaces) that stops "
-        "response generation if the model encounters it. The sequence is not included "
-        "as part of the response. You can add up to five stop sequences."
-    ),
-    key="stop_sequences"
-)
-top_k = st.sidebar.slider(
-    label="Top-K",
-    min_value=1,
-    max_value=40,
-    value=32,
-    step=1,
-    help=(
-        "Top-k changes how the model selects tokens for output. A top-k of 1 means the "
-        "selected token is the most probable among all tokens in the model’s "
-        "vocabulary (also called greedy decoding), while a top-k of 3 means that the "
-        "next token is selected from among the 3 most probable tokens (using "
-        "temperature)."
-    ),
-    key="top_k"
-)
-top_p = st.sidebar.slider(
-    label="Top-P",
-    min_value=0.0,
-    max_value=1.0,
-    value=1.0,
-    step=0.01,
-    help=(
-        "Top-p changes how the model selects tokens for output. Tokens are selected "
-        "from most probable to least until the sum of their probabilities equals the "
-        "top-p value. For example, if tokens A, B, and C have a probability of .3, .2, "
-        "and .1 and the top-p value is .5, then the model will select either A or B as "
-        "the next token (using temperature). "
-    ),
-    key="top_p"
-)
+chat_history = st.session_state.get("chat_history", []) 
 
-# Main area for chatbot
-st.header("Chatbot")
-chatbot = st.session_state.get("chatbot", [])
-if len(chatbot) % 2 == 0:
+if len(chat_history) % 2 == 0:
     role = "user"
 else:
     role = "model"
 
-for user_message, model_message in chatbot:
-    if isinstance(user_message, tuple):
-        st.image(user_message[0], use_column_width=True)
-    elif user_message is not None:
-        st.markdown(f"**User:** {user_message}")
-    if model_message is not None:
-        st.markdown(f"**Model:** {model_message}")
-
-# Text input for user message
-user_text = st.text_input("Type your text here:", key="user_text")
-
-# File uploader for user image
-user_image = st.file_uploader("Upload an image file here", type=["png", "jpg", "jpeg"], key="user_image")
-
-# Button for running the bot
-run_button = st.button("Run", key="run_button")
-
-# Logic for handling user input and bot response
-if run_button or user_text or user_image:
-    # Append user input to chatbot history
-    if user_text:
-        chatbot.append((user_text, None))
-    elif user_image:
-        image = Image.open(user_image).convert('RGB')
-        image = preprocess_image(image)
-        image_path = cache_pil_image(image)
-        chatbot.append(((image_path,), None))
-    
-       # Call the bot function with parameters and chatbot history
-    bot_response = bot(
-        google_key=google_key,
-        files=None,
-        temperature=temperature,
-        max_output_tokens=max_output_tokens,
-        stop_sequences=stop_sequences,
-        top_k=top_k,
-        top_p=top_p,
-        chatbot=chatbot
-    )
-
-    # Get the response text from the bot response generator
-    response_text = next(bot_response)
-
-    # Display the user input and the model response
-    if user_text:
-        st.markdown(f"**User:** {user_text}")
-    elif user_image:
-        st.image(user_image, use_column_width=True)
-    st.markdown(f"**Model:** {response_text}")
+for message in chat_history:
+    r, t = message["role"], message["parts"][0]["text"]
+    st.markdown(f"**{r.title()}:** {t}")
     
-    # Update the chatbot history with the model response
-    chatbot[-1][1] = response_text
-    st.session_state["chatbot"] = chatbot
+# Use text_area for multiline input   
+user_input = st.text_area("", height=5)  
+if user_input:
+    chat_history.append({"role": role, "parts": [{"text": user_input}]}) 
+    if role == "user":
+        
+        # Model code
+        model_name = "gemini-pro"
+        model = genai.GenerativeModel(
+            model_name=model_name,   
+            generation_config=generation_config,
+            safety_settings=safety_settings
+        )
+        
+        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: 
+    c.execute("INSERT INTO history VALUES (?, ?)", 
+            (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"])
+
+# Text input for asking questions about the image
+image_question = st.text_input("Ask something about the image:")
+
+if uploaded_file and image_question:
+   image_parts = [
+     {
+       "mime_type": uploaded_file.type,
+       "data": uploaded_file.read() 
+     },
+   ]
+
+   prompt_parts = [
+     image_question,
+     image_parts[0],
+   ]
+
+   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 answer:** {response.text}")