Create app.py

app.py

@@ -0,0 +1,846 @@
+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
+
+
+os.environ["OPENAI_API_KEY"] = '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'
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+
+
+# 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', 'Feature Benefits', 'Identify Avatars', 'Tone of Voice Manual'))
+
+
+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')
+
+    # 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)
+
+    # 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
+
+        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')
+
+    # 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"]
+    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')
+
+    
+
+    # 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"]
+    selected_model = st.selectbox("Choose a model:", models)
+    
+
+    # Let user choose between pros/cons and reviews
+    user_choice = st.selectbox("Select input for avatars:", ('Top Pros/Cons', 'Reviews'))
+
+
+    if user_choice == 'Top Pros/Cons':
+        worksheet = sheet.worksheet('top_pros_cons')
+
+        #st.write("Worksheet:", worksheet)
+        # df_pros_cons = get_as_dataframe(worksheet).dropna()
+
+        data = worksheet.get_all_records()
+        df_pros_cons = pd.DataFrame(data)
+        df_pros_cons.dropna(how='all', inplace=True)
+
+        #st.write(df_pros_cons)
+
+        # Filter pros and cons separately
+        pros_df = df_pros_cons[df_pros_cons['Type'] == 'Pros']
+        cons_df = df_pros_cons[df_pros_cons['Type'] == 'Cons']
+
+        # Initialize pros and cons strings
+        pros_str = "Pros:\n"
+        cons_str = "Cons:\n"
+
+        # Iterate through pros DataFrame and append Theme and Description
+        for _, row in pros_df.iterrows():
+            theme = row['Theme']
+            description = row['Description']
+            pros_str += f"{theme}: {description}\n"
+
+        # Iterate through cons DataFrame and append Theme and Description
+        for _, row in cons_df.iterrows():
+            theme = row['Theme']
+            description = row['Description']
+            cons_str += f"{theme}: {description}\n"
+
+        # Combine pros and cons into a single string
+        pros_and_cons = pros_str + "\n" + cons_str
+
+        #st.write(pros_and_cons)
+
+    elif user_choice == 'Reviews':
+        worksheet = sheet.worksheet('Reviews')
+        # Get all records of the data
+        df = get_as_dataframe(worksheet)
+
+        #st.write(df)
+
+        # df['Body']= df['Body'].astype(str)
+        # # drop rows where 'Body' column has NaN
+        # df = df.dropna(subset=['Body'])
+
+        # ####first chunking
+
+        # separator = '\n\n'
+
+        # pros_and_cons= separator.join(df['Body'])
+
+        # # df['Body']= df['Body'].astype(str)
+        # # # drop rows where 'Body' column has NaN
+        # # df = df.dropna(subset=['Body'])
+
+        # # Clean up data
+        # pros_and_cons = df['Body'].str.cat(sep='\n\n')
+
+        # 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
+        pros_and_cons = body_series.str.cat(sep='\n\n')
+
+
+
+    
+
+    # Get all records of the data
+    #df = get_as_dataframe(worksheet)
+
+    
+
+    # Display pros and cons or reviews to the user
+    #st.text('Selected pros and cons or reviews:')
+    #st.write(pros_and_cons)
+
+    # Prepare the prompt
+    prompt = """Below are the pros and cons we have identified from customer reviews 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(pros_and_cons)
+
+    # Editable prompt
+    prompt = st.text_area("Edit the prompt:", value=prompt, height=200)
+
+    if st.button('Generate avatars'):
+        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
+
+        # if "generate_more" not in st.session_state:
+        #     st.session_state.generate_more = False
+
+        # if st.button('Generate more avatars'):
+        #     st.session_state.generate_more = True
+
+
+        # if st.session_state.generate_more:
+
+        #     messages1 = [
+        #         {"role": "system", "content": "You are a helpful assistant who helps identify avatars from product reviews"},
+        #         {"role": "user", "content": """Please summarize these avatars. 
+        #         mention their income in summary. /n {}""".format(model_response)}
+        #     ]
+            
+        #     model_response1 = get_chatgpt_response(messages1, selected_model)
+    
+        #     prompt2 = """Below are the pros and cons we have identified from customer reviews for our product:
+
+        #     -----------------------------------------------
+        #     {}
+
+        #     -----------------------------------------------
+        #     please exclude these avatar as we already have them. this is summary of earlier avatars
+
+        #     {}
+        #     -----------------------------------------------
+        #     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(pros_and_cons, model_response1)
+
+        #     # Editable prompt
+        #     prompt2 = st.text_area("Edit the prompt:", value=prompt2, height=200)
+
+        #     if st.button('Generate additional avatars'):
+        #         st.session_state.more_avatars_generated = True
+
+        #         messages2 = [
+        #             {"role": "system", "content": "You are a helpful assistant who helps identify avatars from product reviews"},
+        #             {"role": "user", "content": prompt2}
+        #         ]
+
+        #         # Get model response
+        #         model_response2 = get_chatgpt_response(messages2, selected_model)
+
+        #         final_avatars= model_response + '\n\n' + model_response2
+
+        #         st.write(final_avatars)
+
+
+        #         st.session_state.avatars = final_avatars
+
+        #     else:
+        #         st.write(st.session_state.avatars)
+
+    
+
+    # 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')
+    
+    # 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"]
+    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}")
+