add gradio application

app.py

@@ -0,0 +1,195 @@
+import google.generativeai as genai
+import pandas as pd
+import sqlite3
+import os
+import gradio as gr
+from google.api_core import retry
+
+
+GOOGLE_API_KEY = os.environ['GOOGLE_API_KEY'] 
+
+genai.configure(api_key=GOOGLE_API_KEY)
+
+df = pd.read_excel(
+    'https://public.tableau.com/app/sample-data/sample_-_superstore.xls'
+)
+
+# Function to convert column names to snake case
+def to_snake_case(name):
+    name = name.lower().replace(' ', '_').replace('-','_')
+    return name
+
+# Apply the function to rename columns
+df = df.rename(columns=to_snake_case)
+
+# Add date abstraction
+df['order_week'] = (pd.to_datetime(df['order_date']) - pd.to_timedelta(df['order_date'].dt.dayofweek, unit='d')).astype(str)
+df['order_year'] = pd.DatetimeIndex(df['order_date']).year
+df['order_month'] = pd.DatetimeIndex(df['order_date']).month
+
+# Connect to the SQLite database (or create it if it doesn't exist)
+db_conn = sqlite3.connect('mydatabase.db', check_same_thread=False)
+
+# Save the DataFrame to an SQLite table named 'orders'
+df.to_sql('orders', db_conn, if_exists='replace', index=False)
+
+# Tools 
+def list_tables() -> list[str]:
+    """Retrieve the names of all tables in the database."""
+    cursor = db_conn.cursor()
+
+    # Fetch the table names.
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+
+    tables = cursor.fetchall()
+    return [t[0] for t in tables]
+
+def describe_table(table_name: str) -> list[tuple[str, str]]:
+    """Look up the table schema.
+
+    Returns:
+      List of columns, where each entry is a tuple of (column, type).
+    """
+
+    cursor = db_conn.cursor()
+
+    cursor.execute(f"PRAGMA table_info({table_name});")
+
+    schema = cursor.fetchall()
+    # [column index, column name, column type, ...]
+    return [(col[1], col[2]) for col in schema]
+
+
+def execute_query(sql: str) -> list[list[str]]:
+    """Execute a SELECT statement, returning the results."""
+    # print("QUERY:", sql)
+    sql = sql.replace("\\", "")
+
+    cursor = db_conn.cursor()
+
+    cursor.execute(sql)
+    return cursor.fetchall()
+
+
+def relative_uplift(anchor_value: float, new_value: float) -> float:
+    """Calculate relative uplift of new value for comparison in percentages
+    if the anchor is negative, make it to absolute first to avoid miscalculation"""
+
+    return (new_value - anchor_value) / abs(anchor_value)
+
+tools = [list_tables, describe_table, execute_query]
+
+instruction = """You are a helpful chatbot that can interact with an SQL database for a
+store. You will take the users questions and turn them into SQL queries using the tools
+available. Once you have the information you need, you will answer the user's question using
+the data returned. You are allowed to do multiple query if the question cannot be done in one go.
+Use list_tables to see what tables are present, describe_table to understand
+the schema, and execute_query to issue an SQL SELECT query.
+
+You can process one by one, not need to do it all at once. 
+
+No need to return output like "Here is the result" or "lets find out" Just return the data itself.
+No need to return the question in the output. Just return the answer. 
+"""
+
+def chat_history_result(chat):
+    """
+    Converts chat history into a tabular format with a primary header indicating the chat context.
+    
+    Parameters:
+    - chat: A chat history object containing roles, messages, and function calls.
+
+    Returns:
+    - A pandas DataFrame with columns: 'Chat ID', 'Role', 'Content', 'Type'.
+    """
+    records = []
+    text_result = ""
+
+    chat_id = 1  # Start chat ID from 1
+
+    for event in chat.history:
+        role = event.role.capitalize()
+
+        for part in event.parts:
+            if txt := part.text:
+                records.append({"Chat ID": chat_id, "Type": "Text", "Role": role, "Content": txt, })
+                if role == 'Model': 
+                  text_result += txt + "\n"
+            elif fn := part.function_call:
+                args = ", ".join(f"{key}={val}" for key, val in fn.args.items())
+                records.append({"Chat ID": chat_id, "Type": "Function Call", "Role": role, "Content": f"Function call: {fn.name}({args})"})
+            elif resp := part.function_response:
+                records.append({"Chat ID": chat_id, "Type": "Function Response", "Role": role, "Content": str(resp)})
+        # Increment chat ID after processing an event to indicate context change
+        chat_id += 1
+
+    # Create a DataFrame from the records
+    df_log = pd.DataFrame(records, columns=["Chat ID", "Role","Type","Content"])
+
+    return df_log, text_result
+
+
+def generate_response(prompt):
+    model = genai.GenerativeModel(
+        "models/gemini-1.5-flash-latest", tools=tools, system_instruction=instruction
+    )
+
+    retry_policy = {"retry": retry.Retry(predicate=retry.if_transient_error)}
+
+    # Start a chat with automatic function calling enabled.
+    chat_model = model.start_chat(enable_automatic_function_calling=True)
+
+    # split prompy by double enter / new lines and send them one by one
+    prompts = prompt.split("\n\n")
+    for prompt in prompts:
+        _ = chat_model.send_message(prompt, request_options=retry_policy)  
+
+    # text_to_display = response_text
+
+    df_chat, text_result = chat_history_result(chat_model)
+
+    text_to_display = text_result
+
+    return text_to_display, df_chat
+
+
+initial_prompt = """Question1: 
+Who bought the most product by quantity and the total of profit from the person? 
+Then Show top 5 item with most profit from that person.
+
+Question2: 
+Compare profit between 2016 May and 2016 June, show the relative uplift of June profit compared to May profit.
+
+Question3: 
+What is the city that generate the most profit then show the profit and quantity
+"""
+block = gr.Blocks()
+
+with block:
+    gr.Markdown(
+    """
+    # Automated Report 
+    ## Explored by Hervind & Nikolas Ermando
+    Opensource Data by Tableau regarding superstore orders
+    * can be accessed in https://www.kaggle.com/datasets/vivek468/superstore-dataset-final
+    """)
+    # prompt_box = gr.Textbox(label="Questions Separate questions by double new line", lines=2)
+
+    prompt_box = gr.Textbox(label="Questions, (separate question by double enter / new lines)", lines=2, value= initial_prompt)
+
+    btn = gr.Button(value="Submit")
+    text_output = gr.Textbox(label="Results")
+    df_output  = gr.DataFrame(label="Process Log")
+
+    btn.click(generate_response, inputs=prompt_box, outputs=[text_output, df_output])
+    block.load(fn = generate_response, inputs=prompt_box, outputs=[text_output, df_output])
+
+    gr.Markdown(
+    """
+    # To Do: 
+    * Explore several data and join tables capability 
+    * In depth Comparison capability between two periods 
+    * Add showing interactive plot based on the question. 
+    """)
+
+block.launch()