app.py

import streamlit as st
import re
import gspread
from gspread_dataframe import get_as_dataframe, set_with_dataframe

import pandas as pd
import os
import openai
import time
import json

os.environ["api_key"] == st.secrets["api_key"]

#os.environ["OPENAI_API_KEY"] = api_key 
openai.api_key = os.getenv("api_key")

os.environ["GSPREAD_CREDENTIALS"]=  st.secrets["GSPREAD_CREDENTIALS"]

#print(type(os.environ["GSPREAD_CREDENTIALS"]))

#print(st.secrets["GSPREAD_CREDENTIALS"], "GSPREAD_CREDENTIALS")

json_credentials= st.secrets["GSPREAD_CREDENTIALS"]

# Parse the JSON content (string) into a Python dictionary
credentials_dict = json.loads(json_credentials)

# Initialize session state
if 'df_final_output' not in st.session_state:
    st.session_state['df_final_output'] = None

# def get_chatgpt_response(messages):
#    response = openai.ChatCompletion.create(
#    model="gpt-3.5-turbo",
#    messages=messages
#  )
#    return  response['choices'][0]['message']['content']

def get_chatgpt_response(messages, selected_model):
    response = openai.ChatCompletion.create(
        model=selected_model,
        messages=messages
    )
    return response['choices'][0]['message']['content']

# Define pages in sidebar
page = st.sidebar.radio('Select a page:', ('Review Analysis', 'review summary', 'Feature Benefits','combined features and benefits', 'feature_mapping', 'benefit_mapping', 'Identify Avatars', 'Tone of Voice Manual', 'question_answers'))


if page == 'Review Analysis':
    st.title('Review Analysis Page')

# Streamlit settings
#st.title('Customer Reviews Analysis')

    # Authenticate Google Sheets API
    #gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')
    # Authenticate Google Sheets API using the dictionary
    gc = gspread.service_account_from_dict(credentials_dict)

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

    user_char_limit = st.number_input("Enter character limit for chunk:", value=9000, step=500)

    # User input for prompts
    phase1_prompt = st.text_area("Enter your prompt for Phase 1- wherever you see '{}', we are passing reviews at that place", value="Analyze a set of customer reviews and identify the unique pros and cons and their themes mentioned by customers. for each pros and cons also mention unique theme associated for that pro/cons. Your response should have format like this.\n\nPros:\n\n1. Theme1 (please replace theme identified here): explanaition\n2. Theme2 (please replace theme identified here): explaination\n\ncons:\n1. Theme1: explanaition\n2. Theme2: explaination\n\nIn your analysis, consider the language and tone used in the reviews to accurately represent the customer's experience. here are the reviews\n {}")
    phase2_prompt = st.text_area("Enter your prompt for Phase 2- wherever you see '{}', we are passing reviews at that place", value="Analyze a set of customer reviews pros/cons and identify the only unique pros and cons and their themes mentioned by customers. for each pros and cons also mention unique theme associated for that pro/cons. Your response should have format like this.\n\nPros:\n\n1. Theme1 (please replace theme identified here): explanaition\n2. Theme2 (please replace theme identified here): explaination\n\ncons:\n1. Theme1: explanaition\n2. Theme2: explaination\n\nIn your analysis, consider the language and tone used in the reviews to accurately represent the customer's experience. here are the reviews\n {}")
    final_prompt = st.text_area("Enter your final prompt", value="please analyze below reviews and give me unique best 20(twenty) pros and cons mentioned. Your response should be in same format in 2 sections. one for pros and other for cons. e.g. Pros:\n1. Quality: explaination, 2. 2nd theme: explaination. \n\n {}\n\nPlease note, response should have 2 sections, one for pros and one for cons. All the unique pros should be in pros section and same should be done for cons. Response format: Pros:\n1. Quality: explaination, 2. 2nd theme: explaination. Make sure your response is long and cover all points (at least top 20 pros and cons)")

    # If the user has input a URL, fetch the data from Google Sheets
    if st.button('generate'):
    #if sheet_url:
    # Extract sheet ID from URL
        sheet_id = sheet_url.split('/')[5]
        # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        #st.session_state['sheet'] = sheet
        # Select sheet named 'Reviews'
        worksheet = sheet.worksheet('Reviews')
        # Get all records of the data
        df = get_as_dataframe(worksheet)
        # Convert dataframe to list and drop NaNs
        df['Body']= df['Body'].astype(str)
        # drop rows where 'Body' column has NaN
        df = df.dropna(subset=['Body'])

        ####first chunking

        char_limit= user_char_limit

        separator = '\n'
        char_limit = 9000

        top_reviews = []

        start_index = 0
        chunk_count = 1
        while start_index < len(df):
            char_count = 0
            end_index = start_index

            # Get the reviews within the character limit
            while end_index < len(df) and char_count + len(df['Body'][end_index]) <= char_limit:
                char_count += len(df['Body'][end_index])
                end_index += 1

            chunk_reviews = df['Body'][start_index:end_index]
            reviews_string = separator.join(chunk_reviews)

            num_reviews = len(chunk_reviews)
            print(f'Chunk {chunk_count}:')
            print(f'Number of reviews: {num_reviews}')
            print(f'Character length: {len(reviews_string)}')

            # For the first phase, replace the hardcoded prompt with the user's input
            messages = [
                {"role": "system", "content": "You are helpful assistant"},
                {"role": "user", "content": phase1_prompt.format(reviews_string)}
            ]

            model_response = get_chatgpt_response(messages, selected_model)

            top_reviews.append(model_response)

            start_index = end_index
            chunk_count += 1
        

        # After the first chunking phase, you create reviews_string_1
        separator = "\n" + "-" * 80 + "\n"
        reviews_string_1 = separator.join(top_reviews)

        print(len(reviews_string_1))

        # Now, we start a loop to repeatedly perform the second chunking phase
        while len(reviews_string_1) > 11000:
            dfn= pd.DataFrame(top_reviews, columns=['pros/cons']) #convert top_reviews in df

            separator = '\n'
            char_limit = 9000

            top_reviews = []

            start_index = 0
            chunk_count = 1
            while start_index < len(dfn):
                char_count = 0
                end_index = start_index

                # Get the reviews within the character limit
                while end_index < len(dfn) and char_count + len(dfn['pros/cons'][end_index]) <= char_limit:
                    char_count += len(dfn['pros/cons'][end_index])
                    end_index += 1

                chunk_reviews = dfn['pros/cons'][start_index:end_index]
                reviews_string = separator.join(chunk_reviews)

                num_reviews = len(chunk_reviews)
                print(f'Chunk {chunk_count}:')
                print(f'Number of reviews: {num_reviews}')
                print(f'Character length: {len(reviews_string)}')
                # For the second phase, replace the hardcoded prompt with the user's input
                messages = [
                    {"role": "system", "content": "You are helpful assistant"},
                    {"role": "user", "content": phase2_prompt.format(reviews_string)}
                ]

                try:
                    model_response = get_chatgpt_response(messages, selected_model)
                    top_reviews.append(model_response)
                except Exception as e:
                    if e.__class__ =="RateLimitError":
                        print("here")
                        time.sleep(30)
                        model_response = get_chatgpt_response(messages, selected_model)

                start_index = end_index
                chunk_count += 1

                # After the second chunking phase, you again create reviews_string_1
            separator = "\n" + "-" * 80 + "\n"
            reviews_string_1 = separator.join(top_reviews)

        # [...]
        # The code continues as is until the final message

        # For the final message, replace the hardcoded prompt with the user's input
        messages = [
            {"role": "system", "content": "You are helpful assistant who analyzes reviews and gives top 20 pros and cons from them"},
            {"role": "user", "content": final_prompt.format(reviews_string_1)}
        ]

        final_output = get_chatgpt_response(messages, selected_model)

        # Display the output
        st.text('Here are the top pros and cons:')
        st.write(final_output)

        st.session_state.df_final_output = final_output

    # Create a button that will trigger writing to Google Sheets
    if st.button('Write output to sheet'):
        #if st.button('Write output to sheet'):
        #st.session_state.df_final_output = final_output

        sheet_id = sheet_url.split('/')[5]
        # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        final_output= st.session_state.df_final_output

        st.write("Button clicked, processing data...")

        lines = final_output.split('\n')
        # Split each line into theme and description
        split_lines = []
        for line in lines:
            if "Pros:" in line:
                type_ = "Pros"
            elif "Cons:" in line:
                type_ = "Cons"
            elif ": " in line:
                theme, description = re.split(r': ', line, 1)
                split_lines.append([type_, theme, description])

        # Convert the list of lists into a DataFrame
        df_final_output = pd.DataFrame(split_lines, columns=['Type', 'Theme', 'Description'])

        st.write(df_final_output)

        # Create a new worksheet and write the final output to it
        # worksheet_output = sheet.add_worksheet(title="top_pros_cons", rows="100", cols="20")
        # set_with_dataframe(worksheet_output, df_final_output)

        # # Then, outside of your if statement for the button click, check if df_final_output exists in the session state
        # if st.session_state.df_final_output is not None:

        try:
            worksheet_output = sheet.add_worksheet(title="top_pros_cons", rows="100", cols="20")
            set_with_dataframe(worksheet_output, df_final_output)
            st.write("Data written successfully to Google Sheets.")
        except Exception as e:
            st.error(f"An error occurred while writing to Google Sheets: {e}")

    # # Wrap your button in a form
    #     with st.form(key='output_form'):
    #         # Change your button click event to set a session state variable
    #         if st.form_submit_button('Write output to sheet'):
    #             # Rest of the code to populate df_final_output
    #             st.session_state.df_final_output = df_final_output

    #     # Then, outside of your form, check if df_final_output exists in the session state
    #     if st.session_state.df_final_output is not None:
    #         try:
    #             worksheet_output = sheet.add_worksheet(title="top_pros_cons", rows="100", cols="20")
    #             set_with_dataframe(worksheet_output, st.session_state.df_final_output)
    #             st.write("Data written successfully to Google Sheets.")
    #         except Exception as e:
    #             st.error(f"An error occurred while writing to Google Sheets: {e}")


if page == 'Feature Benefits':
    st.title('Feature Benefits Page')

    # Authenticate Google Sheets API
    #gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')

    gc = gspread.service_account_from_dict(credentials_dict)

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # # Display default prompt to user
    # default_prompt = """Using below information of the listing, please extract the top 30 Features and Benefits:
    #         Title: {}\n 
    #         bullet_str: {}\n
    #         Legacy Product Description: {}\n
    #         A+ Description: {}\n
    #         Image_text: {}\n
    #         backend_search_terms: {}\n

    #         Please note, you need to create comprehensive top 30 Features and top 30 Benefits for listing using this information. Your response should have 2 sections. one for features and other for benefits
    #         """.format(title, bullet_str, legacy_desc, a_plus_desc, image_text_string, backend_search_terms)

    # prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)
    
    # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Select sheet named 'Listing'
    worksheet = sheet.worksheet('Listing')
    # Get all records of the data
    df = get_as_dataframe(worksheet)

    # Convert DataFrame to strings
    df_str = df.astype(str)

    title = df[df.eq('Title').any(axis=1)].iloc[0, 2]
    bullets = [df[df.eq(f"Bullet #{i}").any(axis=1)].iloc[0, 2] for i in range(1, 6)]

    backend_search_terms = df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)]) > 0 else None

    image_text_row = df[df.eq('Image Text').any(axis=1)]
    image_text = list(image_text_row.dropna(axis=1).iloc[0, :])

    a_plus_desc_mask = df.astype(str).apply(lambda x: 'A+ Description' in ' '.join(x), axis=1)
    if a_plus_desc_mask.any():
        a_plus_desc_row = df[a_plus_desc_mask].index[0]
        a_plus_desc = df.iloc[a_plus_desc_row:, :].fillna('').values.flatten()
        a_plus_desc = ' '.join(a_plus_desc).strip()
    else:
        a_plus_desc = None

    legacy_desc = df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)]) > 0 else None

    image_text_string = ' '.join(image_text)

    bullet_str = ""
    for i, bullet in enumerate(bullets, 1):
        bullet_str += f"Bullet #{i}: {bullet}\n"

    # Display default prompt to user
    default_prompt = """Using below information of the listing, please extract the top 30 Features and Benefits:
    ------------------------------------
    Title: {}\n 
    bullet_str: {}\n
    Legacy Product Description: {}\n
    A+ Description: {}\n
    Image_text: {}\n
    backend_search_terms: {}\n
    -------------------------------------    

        Please note, you need to create comprehensive top 30 Features and top 30 Benefits for listing using this information. Your response should have 2 sections, one for features and other for benefits
            """.format(title, bullet_str, legacy_desc, a_plus_desc, image_text_string, backend_search_terms)

    prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)

    #st.write(prompt)
    
    if st.button('generate'):
        #st.write(prompt)

        messages = [
            {"role": "system", "content": "You are helpful assistant who help create features and benefits for amazon listings"},
            {"role": "user", "content": prompt}
        ]


        # messages = [
        #     {"role": "system", "content": "You are helpful assistant who help create features and benefits for amazon listings"},
        #     {"role": "user", "content": """Using below information of the listing, please extract the top 30 Features and Benefits:
        #      Title: {}\n 
        #      bullet_str: {}\n
        #      Legacy Product Description: {}\n
        #      A+ Description: {}\n
        #      Image_text: {}\n
        #      backend_search_terms: {}\n

        #      Please note, you need to create comprehensive top 30 Features and top 30 Benefits for listing using this information. Your response should have 2 sections. one for features and other for benefits
        #      """.format(title, bullet_str, legacy_desc, a_plus_desc,image_text_string, backend_search_terms)}
        # ]
        
        model_response = get_chatgpt_response(messages, selected_model)

        #st.write(model_response)

        # messages = [
        #     {"role": "system", "content": "You are helpful assistant who help create features and benefits for amazon listings"},
        #     {"role": "user", "content": prompt}
        # ]

        messages1 = [
            {"role": "system", "content": "You are helpful assistant who help create features and benefits for amazon listings"},
            {"role": "user", "content": """{}

            Please re-write above features and benefits in same way in 2 sections.You need to add short heading/theme of 1-3 words for each feature benefit. 
            Your response should have 2 sections. one for features and other for benefits
            e.g features: 1. 100% cotton (this is theme that you will add if not available): 100% cotton cold press paper ensures exceptional quality and strength (this is exisitng description) 2. .....
            Benefits:
            1.Superior Watercolor Surface (this is theme that you will add if not available): Provides a high-quality surface for watercolor painting, with a unique texture that allows for even spreading and vivid colors.(this is exisitng description) 2. ...
            please note, you should not miss any feature benefits. all 30 should be covered with short heading.""".format(model_response)}
        ]

        final_model_response = get_chatgpt_response(messages1, selected_model)

        feature_benefits=final_model_response

        # Display the output
        # Display the output
        st.text('Here are the top features and benefits:')
        st.write(feature_benefits)

        # Store the result in the session state
        st.session_state.feature_benefits = feature_benefits

    # Create a button that will trigger writing to Google Sheets
    if st.button('Write features and benefits to sheet'):
        sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        # Retrieve the result from the session state
        feature_benefits = st.session_state.feature_benefits

        st.write("Button clicked, processing data...")

        lines = feature_benefits.split('\n')

        # # Split each line into feature/benefit and description
        # split_lines = []
        # for line in lines:
        #     if "Features:" in line:
        #         type_ = "Features"
        #     elif "Benefits:" in line:
        #         type_ = "Benefits"
        #     elif ": " in line:
        #         theme, description = re.split(r': ', line, 1)
        #         split_lines.append([type_, theme, description])

        # # Convert the list of lists into a DataFrame
        # df_feature_benefits = pd.DataFrame(split_lines, columns=['Type', 'Theme', 'Description'])

            # Split each line into feature/benefit and description
            # Split each line into feature/benefit and description
        split_lines = []
        for line in lines:
            if "Features:" in line:
                type_ = "Features"
            elif "Benefits:" in line:
                type_ = "Benefits"
            elif line.strip() == '':
                continue  # skip empty lines
            else:
                if ": " in line:  # If theme is present
                    theme, description = re.split(r': ', line, 1)
                else:  # If theme is not present
                    theme = ''
                    description = line.strip()

                split_lines.append([type_, theme, description])

        # Convert the list of lists into a DataFrame
        df_feature_benefits = pd.DataFrame(split_lines, columns=['Type', 'Theme', 'Description'])



        st.write(df_feature_benefits)

        # Create a new worksheet and write the final output to it
        try:
            worksheet_output = sheet.add_worksheet(title="top_features_benefits", rows="100", cols="20")
            set_with_dataframe(worksheet_output, df_feature_benefits)
            st.write("Data written successfully to Google Sheets.")
        except Exception as e:
            st.error(f"An error occurred while writing to Google Sheets: {e}")


if page == 'Identify Avatars':
    st.title('Identify Avatars Page')

    # Authenticate Google Sheets API
   # gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')

    gc = gspread.service_account_from_dict(credentials_dict)

    

    

    # st.title('Identify Avatars Page')

    # # Authenticate Google Sheets API
    # gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')

    

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)
    

    # Let user choose between pros/cons and reviews
    user_choice = st.selectbox("Select input for avatars:", ('review summary', 'Reviews'))

    

    if user_choice == 'review summary':
        worksheet = sheet.worksheet('reviews summary')
        # Get all records of the data
        df = get_as_dataframe(worksheet)


        # Select only the 'Body' column and drop rows with NaN values
        body_series = df['reviews summary'].dropna()

        #### first chunking
        separator = '\n\n'
        pros_and_cons = separator.join(body_series)

        # Clean up data
        reviews_ = body_series.str.cat(sep='\n\n')
        st.session_state.reviews_ = reviews_
        

        

        

    elif user_choice == 'Reviews':
        worksheet = sheet.worksheet('Reviews')
        # Get all records of the data
        df = get_as_dataframe(worksheet)


        # Select only the 'Body' column and drop rows with NaN values
        body_series = df['Body'].dropna()

        #### first chunking
        separator = '\n\n'
        pros_and_cons = separator.join(body_series)

        # Clean up data
        reviews_ = body_series.str.cat(sep='\n\n')
        st.session_state.reviews_ = reviews_


    # Prepare the prompt
    prompt = """Below are the customer reviews/ review summary for our product:

    -----------------------------------------------
    {}

    -----------------------------------------------


    You need to use above information and Write a list of the top 5 Avatars (persona) that you identify from the product reviews of the listing.
    For each avatar pls specify the following:

    - Name
    - Gender
    - Age range
    - Income range
    - Demographics
    - General description of the avatar
    - Personality Traits
    - Interests and Hobbies
    - Pains (Psychological, Spiritual, Physical)
    - Top 10 insecurities
    - Top 10 books that they read with title and author
    - Top 5 movies
    - Top 5 TV shows
    - List their top 10 desires
    - List the social media they use and channels they follow
    - List top 10 lead magnets used for marketing purpose

    And anything else can be used for sales and marketing purpose to target those specific avatars. Please make sure you provide long info for each of the point you mention in avatar""".format(reviews_)

    # Editable prompt
    prompt = st.text_area("Edit the prompt:", value=prompt, height=200)
    


    if st.button('Generate avatars'):
        #formatted_prompt = user_edited_prompt.format(reviews=reviews_)
        messages = [
            {"role": "system", "content": "You are a helpful assistant who helps identify avatars from product reviews"},
            {"role": "user", "content": prompt}
        ]

        # Get model response
        model_response = get_chatgpt_response(messages, selected_model)

        # Display the output
        st.text('Here are the top 5 Avatars:')
        st.write(model_response)

        # Store the result in the session state
        st.session_state.avatars = model_response


    

    # Create a button that will trigger writing to Google Sheets
    if st.button('Write avatars to sheet'):
        sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        # Retrieve the result from the session state
        avatars = st.session_state.avatars

        st.write("Button clicked, processing data...")

        # Create a new worksheet and write the final output to it

        try:
    # Create a new worksheet named "avatars"
            worksheet_output = sheet.add_worksheet(title="avatars", rows="100", cols="20")
            
            # Prepare a list to store the avatar information
            avatars_data = [avatars]

            # Convert the list of avatar data into a DataFrame
            df_avatars = pd.DataFrame(avatars_data, columns=['Avatar Info'])

            # Write the DataFrame to the new "avatars" worksheet
            set_with_dataframe(worksheet_output, df_avatars)
            st.write("Data written successfully to Google Sheets.")
        except Exception as e:
            st.error(f"An error occurred while writing to Google Sheets: {e}")

       


if page == 'Tone of Voice Manual':
    st.title('Tone of Voice Manual Page')
    
    # Authenticate Google Sheets API
    #gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')

    gc = gspread.service_account_from_dict(credentials_dict)
    
    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')
    
    # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

    # Add the prompt
    prompt = """------------------------------------------------------------------------------------------------------
using reviews pros and cons we identified below avatar and related info of avatar for our amazon listing

------------------------------------------------------------------------------------------------------



------------------------------------------------------------------------------------------------------
Please generate a tone of voice manual to address the above Avatar.

can you also address below in tone of voice manual.

1. Make a list of all your communications channels
2. Highlight the tonal values that apply to each channel
3. Write best-practice tone of voice examples

Please make this manual very exhaustive and detailed. explain each of the point with long content

"""
    
    # Editable prompt
    prompt = st.text_area("Edit the prompt:", value=prompt, height=200)
    
    if st.button('Generate Tone of Voice Manual'):
        messages = [
            {"role": "system", "content": "You are a helpful assistant who helps create a tone of voice manual for avatars"},
            {"role": "user", "content": prompt}
        ]

        # Get model response
        model_response = get_chatgpt_response(messages, selected_model)

        # Display the output
        st.text('Generated Tone of Voice Manual:')
        st.write(model_response)

        # Store the result in the session state
        st.session_state.tone_of_voice_manual = model_response

    # Create a button that will trigger writing to Google Sheets
    # if st.button('Write Tone of Voice Manual to sheet'):
    #     sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
    #     sheet = gc.open_by_key(sheet_id)

    #     # Retrieve the result from the session state
    #     tone_of_voice_manual = st.session_state.tone_of_voice_manual

    #     st.write("Button clicked, processing data...")

    #     # Create a new worksheet and write the final output to it
    #     try:
    #         # Create a new worksheet named "tone_of_voice_manual"
    #         worksheet_output = sheet.add_worksheet(title="tone_of_voice_manual", rows="100", cols="20")
            
    #         # Prepare a list to store the tone of voice manual
    #         tone_of_voice_manual_data = [tone_of_voice_manual]

    #         # Convert the list of tone of voice manual data into a DataFrame
    #         df_tone_of_voice_manual = pd.DataFrame(tone_of_voice_manual_data, columns=['Tone of Voice Manual'])

    #         # Write the DataFrame to the new "tone_of_voice_manual" worksheet
    #         set_with_dataframe(worksheet_output, df_tone_of_voice_manual)
    #         st.write("Data written successfully to Google Sheets.")
    #     except Exception as e:
    #         st.error(f"An error occurred while writing to Google Sheets: {e}")

    
    # Write Tone of Voice Manual to sheet
    if st.button('Write Tone of Voice Manual to sheet'):
        sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        # Retrieve the result from the session state
        tone_of_voice_manual = st.session_state.tone_of_voice_manual

        st.write("Button clicked, processing data...")

        try:
            # Check if the "tone_of_voice_manual" worksheet already exists
            worksheet_output = None
            for wks in sheet.worksheets():
                if wks.title == 'tone_of_voice_manual':
                    worksheet_output = wks
                    break

            # If the worksheet does not exist, create a new one
            if worksheet_output is None:
                worksheet_output = sheet.add_worksheet(title="tone_of_voice_manual", rows="100", cols="20")

            # Read the existing data from the worksheet
            existing_data = get_as_dataframe(worksheet_output)

            # Remove empty columns from the existing data
            existing_data = existing_data.dropna(how='all', axis=1)

            # Prepare a list to store the tone of voice manual data
            tone_of_voice_manual_data = [tone_of_voice_manual]

            # Convert the list of tone of voice manual data into a DataFrame
            new_data = pd.DataFrame(tone_of_voice_manual_data, columns=['Tone of Voice Manual'])

            # Append the new data to the existing data
            updated_data = pd.concat([existing_data, new_data], axis=1)

            # Clear the worksheet before writing the updated data
            worksheet_output.clear()

            # Write the updated data to the "tone_of_voice_manual" worksheet
            set_with_dataframe(worksheet_output, updated_data)
            st.write("Data written successfully to Google Sheets.")
        except Exception as e:
            st.error(f"An error occurred while writing to Google Sheets: {e}")




if page == 'review summary':
    st.title('Review summary Page')

    gc = gspread.service_account_from_dict(credentials_dict)

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

     # Set default prompts
    phase1_prompt = "Analyze a set of customer reviews and create a summary of reviews. don't miss any point in your summary\n\n In your analysis, consider the language and tone used in the reviews to accurately represent the customer's experience. here are the reviews\n {}"
    phase2_prompt = "Analyze a set of customer reviews summary and create a summary covering all points. don't create too small summary. it should be exhaustive. \n\n In your analysis, consider the language and tone used in the reviews to accurately represent the customer's experience. here are the review summary \n {}"
    final_prompt = "please analyze below reviews summary and create final review summary in less than 2500 words. don't miss any point in your summary. \n\n In your analysis, consider the language and tone used in the reviews to accurately represent the customer's experience.\n {}"

    editable_phase1_prompt = st.text_area("Edit the first prompt:", value=phase1_prompt, height=200)
    user_char_limit = st.number_input("Enter character limit:", value=9000, step=500)


    # If the user has input a URL, fetch the data from Google Sheets
    if st.button('generate'):
    #if sheet_url:
    # Extract sheet ID from URL
        sheet_id = sheet_url.split('/')[5]
        # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)

        #st.session_state['sheet'] = sheet
        # Select sheet named 'Reviews'
        worksheet = sheet.worksheet('Reviews')
        # Get all records of the data
        df = get_as_dataframe(worksheet)
        # Convert dataframe to list and drop NaNs
        df['Body']= df['Body'].astype(str)
        # drop rows where 'Body' column has NaN
        df = df.dropna(subset=['Body'])

        ####first chunking

        phase1_prompt = editable_phase1_prompt
        char_limit = user_char_limit

        separator = '\n'
        #char_limit = 9000

        top_reviews = []

        start_index = 0
        chunk_count = 1
        while start_index < len(df):
            char_count = 0
            end_index = start_index

            # Get the reviews within the character limit
            while end_index < len(df) and char_count + len(df['Body'][end_index]) <= char_limit:
                char_count += len(df['Body'][end_index])
                end_index += 1

            chunk_reviews = df['Body'][start_index:end_index]
            reviews_string = separator.join(chunk_reviews)

            num_reviews = len(chunk_reviews)
            print(f'Chunk {chunk_count}:')
            print(f'Number of reviews: {num_reviews}')
            print(f'Character length: {len(reviews_string)}')

            # For the first phase, replace the hardcoded prompt with the user's input
            messages = [
                {"role": "system", "content": "You are helpful assistant"},
                {"role": "user", "content": phase1_prompt.format(reviews_string)}
            ]

            model_response = get_chatgpt_response(messages, selected_model)

            top_reviews.append(model_response)

            start_index = end_index
            chunk_count += 1
        

        # After the first chunking phase, you create reviews_string_1
        separator = "\n" + "-" * 80 + "\n"
        reviews_string_1 = separator.join(top_reviews)

        print(len(reviews_string_1))


        if len(reviews_string_1) > 14000:
        # Now, we start a loop to repeatedly perform the second chunking phase
            while len(reviews_string_1) > 11000:
                dfn= pd.DataFrame(top_reviews, columns=['pros/cons']) #convert top_reviews in df

                separator = '\n'
                char_limit = 9000

                top_reviews = []

                start_index = 0
                chunk_count = 1
                while start_index < len(dfn):
                    char_count = 0
                    end_index = start_index

                    # Get the reviews within the character limit
                    while end_index < len(dfn) and char_count + len(dfn['pros/cons'][end_index]) <= char_limit:
                        char_count += len(dfn['pros/cons'][end_index])
                        end_index += 1

                    chunk_reviews = dfn['pros/cons'][start_index:end_index]
                    reviews_string = separator.join(chunk_reviews)

                    num_reviews = len(chunk_reviews)
                    print(f'Chunk {chunk_count}:')
                    print(f'Number of reviews: {num_reviews}')
                    print(f'Character length: {len(reviews_string)}')
                    # For the second phase, replace the hardcoded prompt with the user's input
                    messages = [
                        {"role": "system", "content": "You are helpful assistant"},
                        {"role": "user", "content": phase2_prompt.format(reviews_string)}
                    ]

                    try:
                        model_response = get_chatgpt_response(messages, selected_model)
                        top_reviews.append(model_response)
                    except Exception as e:
                        if e.__class__ =="RateLimitError":
                            print("here")
                            time.sleep(30)
                            model_response = get_chatgpt_response(messages, selected_model)

                    start_index = end_index
                    chunk_count += 1

                    # After the second chunking phase, you again create reviews_string_1
                separator = "\n" + "-" * 80 + "\n"
                reviews_string_1 = separator.join(top_reviews)

            if len(reviews_string_1) > 14000:
                # For the final message, replace the hardcoded prompt with the user's input
                messages = [
                    {"role": "system", "content": "You are helpful assistant who analyzes reviews"},
                    {"role": "user", "content": final_prompt.format(reviews_string_1)}
                ]

                final_output = get_chatgpt_response(messages, selected_model)

                # Display the output
                st.text('Here are the top pros and cons:')
                st.markdown(final_output)

                st.session_state.df_final_output = final_output

            else:
                final_output = reviews_string_1
                st.markdown(final_output)
                st.session_state.df_final_output = final_output
        
        else:
            final_output = reviews_string_1
            print('we are here')
            st.markdown(final_output)
            st.session_state.df_final_output = final_output

    # Create a button that will trigger writing to Google Sheets
    if st.button('Write output to sheet'):
        #if st.button('Write output to sheet'):
        #st.session_state.df_final_output = final_output

        # sheet_id = sheet_url.split('/')[5]
        # # Open the Google spreadsheet
        # sheet = gc.open_by_key(sheet_id)

        final_output= st.session_state.df_final_output

        st.write("Button clicked, processing data...")

        sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
        sheet = gc.open_by_key(sheet_id)



       

        try:
            # Check if the "tone_of_voice_manual" worksheet already exists
            worksheet_output = None
            for wks in sheet.worksheets():
                if wks.title == 'reviews summary':
                    worksheet_output = wks
                    break

            # If the worksheet does not exist, create a new one
            if worksheet_output is None:
                worksheet_output = sheet.add_worksheet(title="reviews summary", rows="100", cols="20")

            # Read the existing data from the worksheet
            existing_data = get_as_dataframe(worksheet_output)

            # Remove empty columns from the existing data
            existing_data = existing_data.dropna(how='all', axis=1)

            # Prepare a list to store the tone of voice manual data
            tone_of_voice_manual_data = [final_output]

            # Convert the list of tone of voice manual data into a DataFrame
            new_data = pd.DataFrame(tone_of_voice_manual_data, columns=['reviews summary'])

            # Append the new data to the existing data
            updated_data = pd.concat([existing_data, new_data], axis=1)

            # Clear the worksheet before writing the updated data
            worksheet_output.clear()

            # Write the updated data to the "tone_of_voice_manual" worksheet
            set_with_dataframe(worksheet_output, updated_data)
            st.write("Data written successfully to Google Sheets.")
        except Exception as e:
            st.error(f"An error occurred while writing to Google Sheets: {e}")


# if page == 'question_answers':
#     st.title('question answers')

#     #gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')
#     gc = gspread.service_account_from_dict(credentials_dict)

#     # Ask user for Google Sheet URL
#     sheet_url = st.text_input('Enter the URL of your Google Sheet')

#     # Add this in the part of your Streamlit app where the user can select the model
#     models = ["gpt-3.5-turbo", "gpt-4"]
#     selected_model = st.selectbox("Choose a model:", models)

#     # Extract sheet ID from URL
#     sheet_id = sheet_url.split('/')[5]
#     # Open the Google spreadsheet
#     sheet = gc.open_by_key(sheet_id)

#     # Select sheet named 'Listing'
#     worksheet = sheet.worksheet('Listing')
#     # Get all records of the data
#     df = get_as_dataframe(worksheet)

#     # Convert DataFrame to strings
#     df_str = df.astype(str)

#     title = df[df.eq('Title').any(axis=1)].iloc[0, 2]
#     bullets = [df[df.eq(f"Bullet #{i}").any(axis=1)].iloc[0, 2] for i in range(1, 6)]

#     backend_search_terms = df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)]) > 0 else None

#     image_text_row = df[df.eq('Image Text').any(axis=1)]
#     image_text = list(image_text_row.dropna(axis=1).iloc[0, :])

#     a_plus_desc_mask = df.astype(str).apply(lambda x: 'A+ Description' in ' '.join(x), axis=1)
#     if a_plus_desc_mask.any():
#         a_plus_desc_row = df[a_plus_desc_mask].index[0]
#         a_plus_desc = df.iloc[a_plus_desc_row:, :].fillna('').values.flatten()
#         a_plus_desc = ' '.join(a_plus_desc).strip()
#     else:
#         a_plus_desc = None

#     legacy_desc = df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)]) > 0 else None

#     image_text_string = ' '.join(image_text)

#     bullet_str = ""
#     for i, bullet in enumerate(bullets, 1):
#         bullet_str += f"Bullet #{i}: {bullet}\n"

#     # Display default prompt to user
#     default_prompt = """Below is data of our products for amazon listing:
#     ------------------------------------
#     Title: {}\n 
#     bullet_str: {}\n
#     Legacy Product Description: {}\n
#     A+ Description: {}\n
#     Image_text: {}\n
#     backend_search_terms: {}\n
#     -------------------------------------    

#     Please create question-answers pairs for amazon listing using this data. 
#     Please segregate them theme wise. themes names should not be features or benefits and create 1 or more questions answer pairs for each theme.
#     questions generated should be potential questions in customer mind before buying product.
#     please create at least 20 question-answers pairs.
#             """.format(title, bullet_str, legacy_desc, a_plus_desc, image_text_string, backend_search_terms)

#     prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)



#     # If the user has input a URL, fetch the data from Google Sheets
#     if st.button('generate'):

#         messages = [
#                     {"role": "system", "content": "You are helpful assistant"},
#                     {"role": "user", "content": prompt}
#                 ]

        

#         model_response = get_chatgpt_response(messages, selected_model)

#         question_answers= model_response

#         st.session_state.question_answers = question_answers

#         st.write(question_answers)

#     def parse_qa(text):
#         try:
#             # Split the text into themes
#             themes = re.split(r'\nTheme: ', text)[1:]
            
#             output = []
#             for theme in themes:
#                 theme_lines = theme.split('\n')
#                 theme_name = theme_lines[0]
#                 qa_pairs = theme_lines[1:]
                
#                 # Extract question and answer pairs
#                 for qa in qa_pairs:
#                     if qa.startswith('Q'):
#                         question = qa.split(': ', 1)[1]
#                     elif qa.startswith('A'):
#                         answer = qa.split(': ', 1)[1]
#                         output.append((theme_name, question, answer))
#             return output, True
#         except Exception as e:
#             return text, False  # Return the full text and a flag indicating the parsing failed

        

#     # # Create a button that will trigger writing to Google Sheets
#     # if st.button('Write output to sheet'):

#     #     final_output= st.session_state.question_answers

#     #     st.write("Button clicked, processing data...")

#     #     sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
#     #     sheet = gc.open_by_key(sheet_id)



       

#     #     try:
#     #         # Check if the "tone_of_voice_manual" worksheet already exists
#     #         worksheet_output = None
#     #         for wks in sheet.worksheets():
#     #             if wks.title == 'question_answers':
#     #                 worksheet_output = wks
#     #                 break

#     #         # If the worksheet does not exist, create a new one
#     #         if worksheet_output is None:
#     #             worksheet_output = sheet.add_worksheet(title="question_answers", rows="100", cols="20")

#     #         # Read the existing data from the worksheet
#     #         existing_data = get_as_dataframe(worksheet_output)

#     #         # Remove empty columns from the existing data
#     #         existing_data = existing_data.dropna(how='all', axis=1)

#     #         # Prepare a list to store the tone of voice manual data
#     #         question_answers_data = [final_output]

#     #         # Convert the list of tone of voice manual data into a DataFrame
#     #         new_data = pd.DataFrame(question_answers_data, columns=['question_answers'])

#     #         # Append the new data to the existing data
#     #         updated_data = pd.concat([existing_data, new_data], axis=1)

#     #         # Clear the worksheet before writing the updated data
#     #         worksheet_output.clear()

#     #         # Write the updated data to the "tone_of_voice_manual" worksheet
#     #         set_with_dataframe(worksheet_output, updated_data)
#     #         st.write("Data written successfully to Google Sheets.")
#     #     except Exception as e:
#     #         st.error(f"An error occurred while writing to Google Sheets: {e}")

#     if st.button('Write output to sheet'):
#         final_output, parsed_successfully = parse_qa(st.session_state.question_answers)

#         st.write("Button clicked, processing data...")

#         sheet_id = sheet_url.split('/')[5]  # Open the Google spreadsheet
#         sheet = gc.open_by_key(sheet_id)

#         try:
#             worksheet_output = None
#             for wks in sheet.worksheets():
#                 if wks.title == 'question_answers':
#                     worksheet_output = wks
#                     break

#             if worksheet_output is None:
#                 worksheet_output = sheet.add_worksheet(title="question_answers", rows="100", cols="20")

#             if parsed_successfully:
#                 new_data = pd.DataFrame(final_output, columns=['Theme', 'Question', 'Answer'])
#             else:
#                 new_data = pd.DataFrame([final_output], columns=['Output'])

#             worksheet_output.clear()
#             set_with_dataframe(worksheet_output, new_data)
#             st.write("Data written successfully to Google Sheets.")
#         except Exception as e:
#             st.error(f"An error occurred while writing to Google Sheets: {e}")

if page == 'question_answers':
    st.title('question answers')

    #gc = gspread.service_account(filename='arctic-rite-381810-e8bee8664772.json')
    #gc = gspread.service_account(filename='arctic-rite-381810-b124ba8c96a9.json')

    gc = gspread.service_account_from_dict(credentials_dict)

    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

        # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Select sheet named 'Listing'
    worksheet = sheet.worksheet('Q&A')
    # Get all records of the data
    df = get_as_dataframe(worksheet)

    df= df.dropna(subset = ['Question', 'Answer'])

    #st.write(df)

    question_answer = "\n".join(["Question: {}\nAnswer: {}".format(q, a) for q, a in zip(df['Question'], df['Answer'])])

    #st.write(question_answer)

    st.write(len(question_answer))

    # Display default prompt to user
    default_prompt = """Below is question-answer pairs from amazon listing:
    ------------------------------------
    {}
    -------------------------------------    
    please analyze these question-answer pairs and group them theme-wise. you have find themes and then group question-answer pairs as per theme. Don't miss any question pair given above. give numbering to questions.
            """.format(question_answer)

    prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)

    # If the user has input a URL, fetch the data from Google Sheets
    if st.button('generate'):

        messages = [
                    {"role": "system", "content": "You are helpful assistant"},
                    {"role": "user", "content": prompt}
                ]

        model_response = get_chatgpt_response(messages, selected_model)

        question_answers= model_response

        st.session_state.question_answers = question_answers

        st.write(question_answers)


    if st.button('Write output to sheet'):
            question_answers = st.session_state.question_answers
            # Create a new Google Sheets file

            try:
                new_worksheet = sheet.worksheet('QnA_analyzed')
            except gspread.exceptions.WorksheetNotFound:
                # If it doesn't exist, create it
                new_worksheet = sheet.add_worksheet(title="QnA_analyzed", rows="100", cols="20")
                

            # Add rows one by one
            new_worksheet.append_row(['question_answers', question_answers])
            st.write('Done!')


if page == 'feature_mapping':
    st.title('feature_mapping')

    gc = gspread.service_account_from_dict(credentials_dict)

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

    # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Select sheet named 'Listing'
    worksheet = sheet.worksheet('Listing')
    # Get all records of the data
    df = get_as_dataframe(worksheet)

    # Convert DataFrame to strings
    df_str = df.astype(str)

    title = df[df.eq('Title').any(axis=1)].iloc[0, 2]
    bullets = [df[df.eq(f"Bullet #{i}").any(axis=1)].iloc[0, 2] for i in range(1, 6)]

    backend_search_terms = df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)]) > 0 else None

    image_text_row = df[df.eq('Image Text').any(axis=1)]
    image_text = list(image_text_row.dropna(axis=1).iloc[0, :])

    a_plus_desc_mask = df.astype(str).apply(lambda x: 'A+ Description' in ' '.join(x), axis=1)
    if a_plus_desc_mask.any():
        a_plus_desc_row = df[a_plus_desc_mask].index[0]
        a_plus_desc = df.iloc[a_plus_desc_row:, :].fillna('').values.flatten()
        a_plus_desc = ' '.join(a_plus_desc).strip()
    else:
        a_plus_desc = None

    legacy_desc = df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)]) > 0 else None

    image_text_string = ' '.join(image_text)

    bullet_str = ""
    for i, bullet in enumerate(bullets, 1):
        bullet_str += f"Bullet #{i}: {bullet}\n"

    # Display default prompt to user
    default_prompt = """Features: 
1) Professional Artist Testing: Developed and tested by professional artists to ensure exceptional product quality and results for all types of artistic expression.
2) 1:1 Aspect Ratio: Square aspect ratio of 1:1 facilitates an easy design process and balanced compositions based on famous artworks.
3) 100% Cotton Fibers: Uses 100% cotton fibers to provide natural and lasting beauty and exceptional resistance to scratching and erasing.
4) Gelatin-sized Paper: Offers astounding absorbency resulting in harmonious, natural grain texture and no optical brightening agents that maintain the original brightness of the artwork.
5) Cold & Hot Presses: Available in both cold press and hot press finishes, resulting in slightly textured, toothed surfaces (cold press) for depth and almost no tooth (hot press) surfaces for seamless blending, overlay, or paint removal.
6) European Mill Crafting: Crafted by European mill masters with over 400 years of paper-making experience, ensuring that you produce your finest works.
7) Easy-Block Format: Offers a unique "Easy-Block" format that eliminates the need to stretch watercolor paper sheets, saves time and effort, and ensures that paint dries to the desired texture and prevent buckling or creasing.
8) 2 Glued, 2 Open Edges: Glued on 2 edges and open on 2 edges for easy removal of finished painting, saving time and effort while maintaining paper integrity and preservation.
9) Travel-friendly: Suitable for travel, providing increased convenience to artists.
10) Various Paper Weights: Available in a range of paper weights, ensuring maximum versatility for different artistic styles and techniques.
11) 100 Series Youth Quality: Offers youth quality in the 100 series, providing a traditional watercolor feel for artistic expression.
12) Cotton & Wood Pulp Choices: Offers two different choices of watercolor paper: 100% cotton pulp and 100% wood pulp.
13) Indoor & Outdoor Use: Designed for use indoors and outdoors, providing versatility for artists on the go.
14) 14 Cold-pressed Sheets: Offers 14 sheets of cold-pressed, textured watercolor paper, providing ample surface area for larger projects.
15) Glue Binding: Offers glue binding for easy tearing out of pages, allowing for experimentation and perfecting techniques.
16) Drawing, Sketching, Painting: Versatile for drawing, sketching, and painting.
17) Mixed Media Suitable: Top choice for mixed media projects.
18) Artist-approved: Tested and approved by artists.
19) Chlorine-free & pH-neutral: Chlorine-free, pH-neutral, and archival, ensuring the longevity of artwork.
20) Natural White Paper: Natural white, providing a textured surface for extraordinary vibrant colors.
21) Rough Watercolor Paper: Rough, providing both smooth and textured surfaces for experimentation.
22) Dual-Sided Surfaces: Dual-sided with smooth and textured surfaces.
23) Expert Quality: Provides expert quality for perfect combination of durability and ease of use.
24) Art-N-Fly Compatibility: Compatible with Art-N-Fly Watercolor Pens.
25) Historic Paper Quality: Offers exceptional papers since the 1700s.
26) Calcium Carbonate Buffer: Buffered with calcium carbonate for added protection.
27) Random Texture: Provides a distinctive random texture.
28) Internally Sized: Internally sized to maintain paper integrity and prevent paper deterioration.


--------------------------------------------------------------------------------------------

You have to search for presence of above features in below information of listing:

--------------------------------------------------------------------------------------------
    ------------------------------------
    Title: {}\n 
    bullet_str: {}\n
    Legacy Product Description: {}\n
    A+ Description: {}\n
    Image_text: {}\n
    backend_search_terms: {}\n
    ------------------------------------- 



    Please carefully read the given information of listing and create feature present matrix. if feature is present then you have to mark it using 1 and if absent leave empty. please create in table format. please include feature name in the table. note, only present features should be covered. You have to explain at the end where did you find the present features. also once table is ready create one json that I can easily load in pandas df
            """.format(title, bullet_str, legacy_desc, a_plus_desc, image_text_string, backend_search_terms)

    prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)



    # If the user has input a URL, fetch the data from Google Sheets
    if st.button('generate'):

        messages = [
                    {"role": "system", "content": "You are helpful assistant"},
                    {"role": "user", "content": prompt}
                ]

        

        model_response = get_chatgpt_response(messages, selected_model)

        feature_mapping= model_response

        st.session_state.feature_mapping = feature_mapping

        st.write(feature_mapping)


if page == 'benefit_mapping':
    st.title('benefit_mapping')

    
    gc = gspread.service_account_from_dict(credentials_dict)

    # Ask user for Google Sheet URL
    sheet_url = st.text_input('Enter the URL of your Google Sheet')

    # Add this in the part of your Streamlit app where the user can select the model
    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

    # Extract sheet ID from URL
    sheet_id = sheet_url.split('/')[5]
    # Open the Google spreadsheet
    sheet = gc.open_by_key(sheet_id)

    # Select sheet named 'Listing'
    worksheet = sheet.worksheet('Listing')
    # Get all records of the data
    df = get_as_dataframe(worksheet)

    # Convert DataFrame to strings
    df_str = df.astype(str)

    title = df[df.eq('Title').any(axis=1)].iloc[0, 2]
    bullets = [df[df.eq(f"Bullet #{i}").any(axis=1)].iloc[0, 2] for i in range(1, 6)]

    backend_search_terms = df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Backend Search Terms' in ' '.join(x), axis=1)]) > 0 else None

    image_text_row = df[df.eq('Image Text').any(axis=1)]
    image_text = list(image_text_row.dropna(axis=1).iloc[0, :])

    a_plus_desc_mask = df.astype(str).apply(lambda x: 'A+ Description' in ' '.join(x), axis=1)
    if a_plus_desc_mask.any():
        a_plus_desc_row = df[a_plus_desc_mask].index[0]
        a_plus_desc = df.iloc[a_plus_desc_row:, :].fillna('').values.flatten()
        a_plus_desc = ' '.join(a_plus_desc).strip()
    else:
        a_plus_desc = None

    legacy_desc = df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)].iloc[0, 2] if len(df[df.astype(str).apply(lambda x: 'Legacy Product Description' in ' '.join(x), axis=1)]) > 0 else None

    image_text_string = ' '.join(image_text)

    bullet_str = ""
    for i, bullet in enumerate(bullets, 1):
        bullet_str += f"Bullet #{i}: {bullet}\n"

    # Display default prompt to user
    default_prompt = """Benefits:
1) Long-lasting Artwork: Exceptional product quality ensures long-lasting, beautiful artwork and exceptional results for various artistic expressions.
2) Easy Composition: A square aspect ratio of 1:1 on the paper facilitates an easy design process and balanced compositions based on famous artworks.
3) Natural Beauty: 100% cotton fibers provide natural and lasting beauty and exceptional resistance to scratching and erasing.
4) Superior Absorbency: Gelatin-sized paper offers astounding absorbency resulting in harmonious, natural grain texture and no optical brightening agents that maintain the original brightness of the artwork.
5) Versatile Finishes: Available in both cold press and hot press finishes result in slightly textured, toothed surfaces (cold press) for depth and almost no tooth (hot press) surfaces for seamless blending, overlay, or paint removal and provide vibrantly versatile paper for customization based on the artist's preference.
6) Expert Craftsmanship: Crafted by experienced mill masters guarantees that artists produce their finest works.
7) No Stretching Needed: Unique "Easy-Block" format eliminates the need to stretch watercolor paper sheets, saves time and effort, and ensures that paint dries to the desired texture and prevents buckling or creasing.
8) Easy Painting Removal: Glued on 2 edges and open on 2 edges for easy removal of finished painting saves time and effort while maintaining paper integrity and preservation.
9) Travel Convenience: Suitable for travel, providing increased convenience to artists.
10) Versatility: Available in a range of paper weights ensures maximum versatility for different artistic styles and techniques.
11) Time & Money Savings: Saves time and money with ready-made sizes.
12) Durable Preservation: Durable material for long-lasting preservation.
13) Traditional Feel: Traditional watercolor feel for artistic expression.
14) Ample Surface Area: Provides ample surface area for larger projects.
15) Superior Value: Superior value compared to other brands.
16) Artistic Versatility: Approved by professional artists for various artistic endeavors.
17) Mixed Media Ideal: Suitable for creating mixed media artwork.
18) Professional Quality: Ensures the longevity of artwork with high-quality material.
19) Artwork Longevity: Provides a textured surface for extraordinary vibrant colors, contributing to artwork longevity.
20) Beautiful Paintings: Ideal for creating beautiful artwork for weddings, gifts, and more.
21) Vibrant Colors: Provides a textured surface that results in extraordinary vibrant colors.
22) Technique Experimentation: Offers both smooth and textured surfaces for experimentation with different techniques.
23) Creative Possibilities: Versatile enough for painting, sketching, printmaking, or drawing.
24) Durable & Easy: Smooth edges and easy tear sheets ensure no damage to artwork.
25) Professional Look: Provides a professional appearance for watercolor paintings.
26) Unique Artisan Touch: Innovative artisan paper adds a unique touch to artwork.
27) Added Protection: High-quality material ensures artwork longevity and protection.
28) Budget-friendly: Cost-effective paper for budget-conscious artists.
29) Quality Assurance: Highest grade of watercolor paper available, providing quality assurance and contributing to artistic confidence.


--------------------------------------------------------------------------------------------

You have to search for presence of above Benefits in below information of listing:

--------------------------------------------------------------------------------------------
    ------------------------------------
    Title: {}\n 
    bullet_str: {}\n
    Legacy Product Description: {}\n
    A+ Description: {}\n
    Image_text: {}\n
    backend_search_terms: {}\n
    ------------------------------------- 



    Please carefully read the given information of listing and create Benefits present matrix. if Benefit is present then you have to mark it using 1 and if absent leave empty. please create in table format. note, only present Benefits should be covered. please include benefit name in the table. You have to explain at the end where did you find the present Benefits. also once table is ready create one json that I can easily load in pandas df
            """.format(title, bullet_str, legacy_desc, a_plus_desc, image_text_string, backend_search_terms)

    prompt = st.text_area("Edit the prompt:", value=default_prompt, height=200)



    # If the user has input a URL, fetch the data from Google Sheets
    if st.button('generate'):

        messages = [
                    {"role": "system", "content": "You are helpful assistant"},
                    {"role": "user", "content": prompt}
                ]

        

        model_response = get_chatgpt_response(messages, selected_model)

        benefit_mapping= model_response

        st.session_state.feature_mapping = benefit_mapping

        st.write(benefit_mapping)



import textwrap
from gspread_dataframe import get_as_dataframe

# def page_combined_features_and_benefits():
#     st.title('combined features and benefits')
#     gc = gspread.service_account_from_dict(credentials_dict)

#     # Use a text area for URLs input
#     sheet_urls_input = st.text_area('Enter the URLs of your Google Sheets, each on a new line')
#     sheet_urls = sheet_urls_input.split('\n')  # split input into a list of URLs

#     if sheet_urls:
#         st.write('You entered these URLs:')
#         for url in sheet_urls:
#             st.write(url)

#     models = ["gpt-3.5-turbo", "gpt-4", "gpt-3.5-turbo-16k"]
#     selected_model = st.selectbox("Choose a model:", models)

#     user_char_limit = st.number_input("Enter character limit for chunk:", value=9000, step=500)

#     all_feature_benefit_strings = []

#     if st.button('generate'):
#         # Read all features and benefits from all sheets separately
#         for sheet_url in sheet_urls:
#             feature_benefit_strings = []
#             sheet_id = sheet_url.split('/')[5]
#             sheet = gc.open_by_key(sheet_id)
#             worksheet_name = 'top_features_benefits'
#             worksheet = sheet.worksheet(worksheet_name)
#             df = get_as_dataframe(worksheet).dropna(how='all')

#             for _, row in df.iterrows():
#                 feature_benefit_strings.append(f"{row['Type']} {row['Theme']}: {row['Description']}")

#             # Process the strings for each sheet separately
#             chunk_string = "\n".join(feature_benefit_strings)
#             if len(chunk_string) <= user_char_limit:
#                 messages = [
#                     {"role": "system", "content": "You are helpful assistant."},
#                     {"role": "user", "content": f"from below features and benefits, please get top 25 features and benefits. top features or benefits are those which are more prominenent/repeated. please create 2 sections each for features and benefits in your response\n{chunk_string}"}
#                 ]
#                 model_response = get_chatgpt_response(messages, selected_model)
#                 processed_strings = model_response
#                 all_feature_benefit_strings.append(processed_strings)

#         # Check if the length of the final string is less than the user-defined character limit
#         final_string = "\n".join(all_feature_benefit_strings)

#         #st.write(final_string)

#         while len(final_string) > user_char_limit:
#             chunks = textwrap.wrap(final_string, user_char_limit)
#             all_processed_strings = []

#             for chunk in chunks:
#                 messages = [
#                     {"role": "system", "content": "You are helpful assistant."},
#                     {"role": "user", "content": f"from below features and benefits, please get top 25 features and benefits. top features or benefits are those which are more prominenent/repeated. please create 2 sections each for features and benefits in your response\n{chunk}"}
#                 ]
#                 model_response = get_chatgpt_response(messages, selected_model)
#                 processed_strings = model_response
#                 all_processed_strings.append(processed_strings)

#             final_string = "\n".join(all_processed_strings)

#         # Run the final prompt
#         messages = [
#             {"role": "system", "content": "You are helpful assistant."},
#             {"role": "user", "content": f"from below features and benefits, please get top 30 features and top 30 benefits. top features or benefits are those which are more prominenent/repeated. please create 2 sections each for features and benefits in your response\n{final_string}"}
#         ]
#         final_model_response = get_chatgpt_response(messages, selected_model)
#         st.write('final response')
#         st.write(final_model_response)

    

# if page == 'combined features and benefits':
#     page_combined_features_and_benefits()

# import textwrap
# from gspread_dataframe import get_as_dataframe



def page_combined_features_and_benefits():
    st.title('combined features and benefits')

    #gc = gspread.service_account(filename='arctic-rite-381810-b124ba8c96a9.json')
    gc = gspread.service_account_from_dict(credentials_dict)
    #gc = gspread.service_account_from_dict(credentials_dict)

    # Use a text area for URLs input
    sheet_urls_input = st.text_area('Enter the URLs of your Google Sheets, each on a new line')
    sheet_urls = sheet_urls_input.split('\n')  # split input into a list of URLs

    if sheet_urls:
        st.write('You entered these URLs:')
        for url in sheet_urls:
            st.write(url)

    models = ["gpt-3.5-turbo","gpt-4-0125-preview", "gpt-3.5-turbo-0125" ]
    selected_model = st.selectbox("Choose a model:", models)

    user_char_limit = st.number_input("Enter character limit for chunk:", value=9000, step=500)

    # Provide a default message for user to edit for final prompt
    default_message = "From below features and benefits, please get top 30 features and top 30 benefits. Top features or benefits are those which are more prominent/repeated. Please create 2 sections each for features and benefits in your response\n{}"
    user_message = st.text_area("Edit the final message to be sent:", default_message)

    all_feature_benefit_strings = []

    if st.button('generate'):
        # Read all features and benefits from all sheets separately
        for sheet_url in sheet_urls:
            feature_benefit_strings = []
            sheet_id = sheet_url.split('/')[5]
            sheet = gc.open_by_key(sheet_id)
            worksheet_name = 'top_features_benefits'
            worksheet = sheet.worksheet(worksheet_name)
            df = get_as_dataframe(worksheet).dropna(how='all')

            for _, row in df.iterrows():
                feature_benefit_strings.append(f"{row['Type']} {row['Theme']}: {row['Description']}")

            # Process the strings for each sheet separately
            chunk_string = "\n".join(feature_benefit_strings)
            if len(chunk_string) <= user_char_limit:
                messages = [
                    {"role": "system", "content": "You are helpful assistant."},
                    {"role": "user", "content": f"from below features and benefits, please get top 25 features and benefits. top features or benefits are those which are more prominenent/repeated. please create 2 sections each for features and benefits in your response\n{chunk_string}"}
                ]
                model_response = get_chatgpt_response(messages, selected_model)
                processed_strings = model_response
                all_feature_benefit_strings.append(processed_strings)

        # Check if the length of the final string is less than the user-defined character limit
        final_string = "\n".join(all_feature_benefit_strings)

        # Run the final prompt
        messages = [
            {"role": "system", "content": "You are helpful assistant."},
            {"role": "user", "content": user_message.format(final_string)}
        ]
        final_model_response = get_chatgpt_response(messages, selected_model)
        st.write('final response')
        st.write(final_model_response)

if page == 'combined features and benefits':
    page_combined_features_and_benefits()