app.py

import streamlit as st
from cryptography.fernet import Fernet
import time
import pandas as pd
import io
from transformers import pipeline
from streamlit_extras.stylable_container import stylable_container
import json

st.subheader("Table Question Answering (QA)", divider="blue")

# generate Fernet key
if 'fernet_key' not in st.session_state:
    st.session_state.fernet_key = Fernet.generate_key()

key = st.session_state.fernet_key


# function for generating and validating fernet key
def generate_fernet_token(key, data):
    fernet = Fernet(key)
    token = fernet.encrypt(data.encode())
    return token

def validate_fernet_token(key, token, ttl_seconds):
    
    fernet = Fernet(key)
    try:
        decrypted_data = fernet.decrypt(token, ttl=ttl_seconds).decode()
        return decrypted_data, None
    except Exception as e:
        return None, f"Expired token: {e}"

# sidebar
with st.sidebar:
    with stylable_container(
        key="test_button",
        css_styles="""
        button {
            background-color: yellow;
            border: 1px solid black;
            padding: 5px;
            color: black;
        }
        """,
    ):
        st.button("ONE-DAY SUBSCRIPTION")
   

    expander = st.expander("**Important notes on the Table Question Answering (QA) App**")
    expander.write('''
    
    **Supported File Formats**
    This app accepts files in .csv and .xlsx formats.
    
    
    **How to Use**
    Upload your file first. Then, type your question into the text area provided and click the 'Retrieve your answer' button.
    
    
    **Usage Limits**
    You can ask up to 30 questions per day. Once you reach this limit, you will need to wait until the daily automatic renewal to continue using the app. The app's daily renewal occurs automatically.
    
    
    **Subscription Management**
    This app uses a one-day subscription plan. To cancel your subscription, please visit your Account settings.
    
    
    **Authorization**
    For security purposes, your authorization access expires hourly. To restore access, click the "Request Authorization" button. A file must be uploaded before you can request authorization.
    
    
    **Customization**
    To change the app's background color to white or black, click the three-dot menu on the right-hand side of your app, go to Settings and then Choose app theme, colors and fonts.
    
    
    **File Handling and Errors**
    The app may display an error message if your file is corrupt, contains missing values, or has other errors.
    To get your file cleaned and pre-processed before using this QA app, please use our Text Preprocessing Service which can be found in the navigation menu of our website: https://nlpblogs.com/
    
    For any other errors or inquiries, please contact us at [email protected]
    
''')
    
    
# count attempts based on questions
if 'question_attempts' not in st.session_state:
    st.session_state['question_attempts'] = 0

max_attempts = 3

# upload file
upload_file = st.file_uploader("Upload your file. Accepted file formats include: .csv, .xlsx", type=['csv', 'xlsx'])
df = None

if upload_file is not None:
    file_extension = upload_file.name.split('.')[-1].lower()
    if file_extension == 'csv':
        try:
            df = pd.read_csv(io.StringIO(upload_file.getvalue().decode("utf-8")))
            if df.isnull().values.any():
                st.error("Error: The CSV file contains missing values.")
                st.stop()
            else:
                new_columns = [f'column_{i+1}' for i in range(len(df.columns))]
                df.columns = new_columns
                
                st.dataframe(df, key="csv_dataframe")
                st.write("_number of rows_", df.shape[0])
                st.write("_number of columns_", df.shape[1])
        except pd.errors.ParserError:
            st.error("Error: The CSV file is not readable or is incorrectly formatted.")
            st.stop()
        except UnicodeDecodeError:
            st.error("Error: The CSV file could not be decoded.")
            st.stop()
        except Exception as e:
            st.error(f"An unexpected error occurred while reading CSV: {e}")
            st.stop()
    elif file_extension == 'xlsx':
        try:
            df = pd.read_excel(io.BytesIO(upload_file.getvalue()))
            if df.isnull().values.any():
                st.error("Error: The Excel file contains missing values.")
                st.stop()
            else:
                new_columns = [f'column_{i+1}' for i in range(len(df.columns))]
                df.columns = new_columns
                st.dataframe(df, key="excel_dataframe")
                st.write("_number of rows_", df.shape[0])
                st.write("_number of columns_", df.shape[1])
        except ValueError:
            st.error("Error: The Excel file is not readable or is incorrectly formatted.")
            st.stop()
        except Exception as e:
            st.error(f"An unexpected error occurred while reading Excel: {e}")
            st.stop()
    else:
        st.warning("Unsupported file type.")
        st.stop()

# generate and validate Fernet token for the current file
if 'fernet_token' not in st.session_state:
    if df is not None:
        st.session_state.fernet_token = generate_fernet_token(key, df.to_json())
    else:
        st.stop()

decrypted_data_streamlit, error_streamlit = validate_fernet_token(key, st.session_state.fernet_token, ttl_seconds=10)

if error_streamlit:
    st.warning("Please press Request Authorization. Please note that a file should be uploaded before you press Request Authorization.")
    if st.button("Request Authorization"):
        st.session_state.fernet_token = generate_fernet_token(key, df.to_json())
        st.success("Authorization granted")
        decrypted_data_streamlit, error_streamlit = validate_fernet_token(key, st.session_state.fernet_token, ttl_seconds=10)
        if error_streamlit:
            st.error(f"Your authorization has expired: {error_streamlit}")
            st.stop()
        if error_streamlit:
            st.error("Please upload a file.")
            st.stop()
        else:
            try:
                df = pd.read_json(decrypted_data_streamlit)
            except Exception as e:
                st.error(f"Error decoding data: {e}")
                st.stop()
    else:
        st.error(f"Your authorization has expired: {error_streamlit}")
        st.stop()

st.divider()

# ask question
def clear_question():
    st.session_state["question"] = ""

question = st.text_input("Type your question here and then press **Retrieve your answer**:", key="question")
st.button("Clear question", on_click=clear_question)

#retrive answer
if st.button("Retrieve your answer"):
    if st.session_state['question_attempts'] >= max_attempts:
        st.error(f"You have asked {max_attempts} questions. You have reached your daily request limit. Your subscription will renew automatically. To cancel, please go to your Account.")
        st.stop()
    st.session_state['question_attempts'] += 1
    if error_streamlit:
        st.warning("Please enter a question before retrieving the answer.")
    else:
        with st.spinner('Wait for it...'):
            time.sleep(2)
            if df is not None:
                tqa = pipeline(task="table-question-answering", model="google/tapas-base-finetuned-wikisql-supervised")
                st.write(tqa(table=df, query=question)['answer'])

st.divider()
st.write(f"Number of questions asked: {st.session_state['question_attempts']}/{max_attempts}")