Refactor upload handling in client_summary and sem_ppc classes for improved user feedback and session state management

classes/client_summary.py

@@ -1,35 +1,10 @@
 import streamlit as st
-import threading
 from dotenv import load_dotenv
 from helper.telemetry import collect_telemetry
 from helper.upload_File import uploadFile
 from helper.button_behaviour import hide_button
+from helper.initialize_analyze_session import initialize_analyze_session
 
-class ThreadSafeHandler:
-    def __init__(self, placeholder):
-        self.placeholder = placeholder
-        self.lock = threading.Lock()
-
-    def update_info(self, message):
-        with self.lock:
-            try:
-                self.placeholder.info(message)
-            except Exception:
-                pass
-
-    def update_success(self, message):
-        with self.lock:
-            try:
-                self.placeholder.success(message)
-            except Exception:
-                pass
-
-    def update_error(self, message):
-        with self.lock:
-            try:
-                self.placeholder.error(message)
-            except Exception:
-                pass
 
 class CientSummary:
     def __init__(self):
@@ -48,58 +23,43 @@ class CientSummary:
         if 'target_market' not in st.session_state:
             st.session_state['target_market'] = ''
     
-    def process(self):
-        session = st.session_state.analyze
-        if (self.client_summary or self.name or self.website) and session == 'clicked':
-            try:
-                # Prepare client data
-                client_data = {
-                    'client_summary': self.client_summary,
-                    'client_name': self.name,
-                    'client_website': self.website
-                }
-
-                # Placeholder to display feedback
-                handler = ThreadSafeHandler(st.empty())
+    def process (self):
+            with st.spinner('Uploading Client Details...', show_time=True):
+                        st.write('')
+                        client_summary = ""
+                        client_name = ""
+                        client_website = ""
+                        # 
+                        client_summary = f"Client Summary: {self.client_summary}\n"
+                        client_name = f"{self.name}\n"
+                        client_website = f"{self.website}\n"
 
-                def upload_client_data(field_key, field_value):
-                    try:
-                        handler.update_info(f"Uploading {field_key.replace('_', ' ').title()}...")
-                        # Simulate the processing logic here
-                        st.session_state[field_key] = 'uploaded'  # Mock upload success
-                        collect_telemetry({'data_field': field_key.replace('_', ' ').title(), 'result': field_value})
-                        handler.update_success(f"{field_key.replace('_', ' ').title()} uploaded.")
-                    except Exception as e:
-                        handler.update_error(f"Error uploading {field_key.replace('_', ' ').title()}: {e}")
-
-                # Start threads for each client field
-                threads = []
-                for field_key, field_value in client_data.items():
-                    thread = threading.Thread(target=upload_client_data, args=(field_key, field_value))
-                    thread.start()
-                    threads.append(thread)
-
-                # Wait for all threads to complete
-                for t in threads:
-                    t.join()
-
-                # Update session after processing
-                st.session_state['analyzing'] = False
-                st.success("🎉 Client Details Uploaded Successfully!")
-            except AttributeError:
-                st.info("Please fill out all fields first.")
-                hide_button()
+                        debug_client_summary = {'data_field' : 'Client Summary', 'result': client_summary}
+                        debug_client_name = {'data_field' : 'Client Name', 'result': client_name}
+                        debug_client_website = {'data_field' : 'Client Website', 'result': client_website}
 
+                        if self.client_summary:
+                            st.session_state['client_summary'] = 'uploaded'
+                            st.session_state['target_market'] = 'uploaded'
+                            collect_telemetry(debug_client_summary)
+                        if self.name:
+                            st.session_state['client_name'] = 'uploaded'
+                            collect_telemetry(debug_client_website)
+                        if self.website:
+                            st.session_state['client_website'] = 'uploaded'
+                            collect_telemetry(debug_client_name)
+             
     def row1(self):
-        self.client_summary = st.text_area("Client Summary:", help="Name of business, nature of business, location, products/services")
-        session = st.session_state.analyze
-        self.name = st.text_input("Client Name:")
-        self.website = st.text_input("Client Website:")
+            self.client_summary = st.text_area("Client Summary:", help="Name of business, nature of business, location, products/services")
+            session = st.session_state.analyze
+            self.name = st.text_input("Client Name:")
+            self.website = st.text_input("Client Website:")
+
+            if (self.client_summary or self.name or self.website) and session == 'clicked':
+                self.process()
 
-        if (self.client_summary or self.name or self.website) and session == 'clicked':
-            self.process()  # Call process method to initiate processing
 
 if __name__ == "__main__":
     st.set_page_config(layout="wide")
 
-    upload = uploadFile()  # Assuming this is another helper class handling file uploads
+upload = uploadFile()

classes/sem_ppc.py

@@ -1,106 +1,161 @@
 import streamlit as st
-import threading
 from dotenv import load_dotenv
 from helper.telemetry import collect_telemetry
 from helper.upload_File import uploadFile
 from helper.button_behaviour import hide_button
 
-class ThreadSafeHandler:
-    def __init__(self, placeholder):
-        self.placeholder = placeholder
-        self.lock = threading.Lock()
-
-    def update_info(self, message):
-        with self.lock:
-            try:
-                self.placeholder.info(message)
-            except Exception:
-                pass
-
-    def update_success(self, message):
-        with self.lock:
-            try:
-                self.placeholder.success(message)
-            except Exception:
-                pass
-
-    def update_error(self, message):
-        with self.lock:
-            try:
-                self.placeholder.error(message)
-            except Exception:
-                pass
 
 class Sem_PPC:
     def __init__(self, model_url):
         self.file_dict = {}
         self.model_url = model_url
+        #self.analyst_name = analyst_name
+        #self.data_src = data_src
+        #self.analyst_description = analyst_description
         self.initialize()
         self.row1()
 
     def initialize(self):
+        # FOR ENV
         load_dotenv()
-        # Initialize session state for various ads
-        for ad_type in ['account_set_up', 'search_ads', 'display_ads', 'mobile_ads', 'video_ads', 'shopping_ads']:
-            if ad_type not in st.session_state:
-                st.session_state[ad_type] = ''
+        '''
+        # AGENT NAME
+        st.header(self.analyst_name)
+
+        # EVALUATION FORM LINK
+        url = os.getenv('Link')
+        st.write('Evaluation Form: [Link](%s)' % url)
+
+        # RETURN BUTTON
+        try:
+            if st.button("Return", type='primary'):
+                st.switch_page("./pages/home.py")
+        except Exception:
+            pass
+        '''
+        if 'account_set_up' not in st.session_state:
+            st.session_state['account_set_up'] = ''
+        if 'search_ads' not in st.session_state:
+            st.session_state['search_ads'] = ''
+        if 'display_ads' not in st.session_state:
+            st.session_state['display_ads'] = ''
+        if 'mobile_ads' not in st.session_state:
+            st.session_state['mobile_ads'] = ''
+        if 'video_ads' not in st.session_state:
+            st.session_state['video_ads'] = ''
+        if 'shopping_ads' not in st.session_state:
+            st.session_state['shopping_ads'] = ''
 
     def process(self):
         session = st.session_state.analyze
-        if any([self.account_set_up, self.search_ads, self.display_ads, self.mobile_ads, self.video_ads, self.shopping_ads]) and session == 'clicked':
-            try:
-                # Prepare ad data
-                ad_data = {
-                    'account_set_up': self.account_set_up,
-                    'search_ads': self.search_ads,
-                    'display_ads': self.display_ads,
-                    'mobile_ads': self.mobile_ads,
-                    'video_ads': self.video_ads,
-                    'shopping_ads': self.shopping_ads
-                }
-
-                # Placeholder to display feedback
-                handler = ThreadSafeHandler(st.empty())
-
-                def upload_ads_data(ad_key, ad_value):
+        if (self.account_set_up or self.search_ads or self.display_ads or self.mobile_ads or self.video_ads or self.shopping_ads) and session == 'clicked':
                     try:
-                        handler.update_info(f"Uploading {ad_key.replace('_', ' ').title()}...")
-                        # Simulate the processing logic here
-                        st.session_state[ad_key] = 'uploaded'  # Mock upload success
-                        collect_telemetry({'data_field': ad_key.replace('_', ' ').title(), 'result': ad_value})
-                        handler.update_success(f"{ad_key.replace('_', ' ').title()} completed.")
-                    except Exception as e:
-                        handler.update_error(f"Error uploading {ad_key.replace('_', ' ').title()}: {e}")
-
-                # Start threads for each ad type
-                threads = []
-                for ad_key, ad_value in ad_data.items():
-                    thread = threading.Thread(target=upload_ads_data, args=(ad_key, ad_value))
-                    thread.start()
-                    threads.append(thread)
-
-                # Wait for all threads to complete
-                for t in threads:
-                    t.join()
-
-                # Update session after processing
-                st.session_state['analyzing'] = False
-                st.success("🎉 SEM/PPC Data Uploaded Successfully!")
-            except AttributeError:
-                st.info("Please upload CSV or PDF files first.")
-                hide_button()
+                        account_set_up = ""
+                        search_ads = ""
+                        display_ads = ""
+                        mobile_ads = ""
+                        video_ads = ""
+                        shopping_ads = ""
+                        with st.spinner('Uploading SEM/PPC...', show_time=True):
+                                st.write('')
+                                # INITIALIZING SESSIONS
+                                #combined_text += f"Client Summary: {st.session_state.nature}\n"
+                                try:
+                                    account_set_up += f"\nAccount Set Up: {self.account_set_up}"
+                                except KeyError:
+                                    pass
+                                try:
+                                    search_ads += f"\nSearch Ads: {self.search_ads}"
+                                except KeyError:
+                                    pass
+                                try:
+                                    display_ads += f"\nDisplay Ads: {self.display_ads}"
+                                except KeyError:
+                                    pass
+                                try:
+                                    mobile_ads += f"\nMobile Ads: {self.mobile_ads}"
+                                except KeyError:
+                                    pass
+                                try:
+                                    video_ads += f"\nVideo Ads: {self.video_ads}"
+                                except KeyError:
+                                    pass
+                                try:
+                                    shopping_ads += f"\nShopping Ads: {self.shopping_ads}"
+                                except KeyError:
+                                    pass
+
+                                # OUTPUT FOR SEO ANALYST
+                                #payload_txt = {"question": combined_text}
+                                #result = self.request_model(payload_txt)
+                                
+                                #end_time = time.time()
+                                #time_lapsed = end_time - start_time
+                                
+                                debug_info_account_set_up = {'data_field' : 'Account Set Up - Google Ads', 'result': account_set_up}
+                                debug_info_search_ads = {'data_field' : 'Search Ads - Google Ads/SEMRush', 'result': search_ads}
+                                debug_info_display_ads = {'data_field' : 'Display Ads - Google Ads/SEMRush', 'result': display_ads}
+                                debug_info_mobile_ads = {'data_field' : 'Mobile Ads - Google Ads', 'result': mobile_ads}
+                                debug_info_video_ads = {'data_field' : 'Video Ads - Google Ads', 'result': video_ads}
+                                debug_info_shopping_ads = {'data_field' : 'Shopping Ads - Google Ads/SEMRush', 'result': shopping_ads}
+
+                                '''
+                                debug_info = {
+                                    #'analyst': self.analyst_name,
+                                    'url_uuid': self.model_url.split("-")[-1],
+                                    'time_lapsed': time_lapsed,
+                                    'payload': payload_txt,
+                                    'result': result,
+                                }
+                                '''
+                                if self.account_set_up:
+                                    st.session_state['account_set_up'] = 'uploaded'
+                                    collect_telemetry(debug_info_account_set_up)
+                                if self.search_ads:
+                                    st.session_state['search_ads'] = 'uploaded'
+                                    collect_telemetry(debug_info_search_ads)
+                                if self.display_ads:
+                                    st.session_state['display_ads'] = 'uploaded'
+                                    collect_telemetry(debug_info_display_ads)
+                                if self.mobile_ads:
+                                    st.session_state['mobile_ads'] = 'uploaded'
+                                    collect_telemetry(debug_info_mobile_ads)
+                                if self.video_ads:
+                                    st.session_state['video_ads'] = 'uploaded'
+                                    collect_telemetry(debug_info_video_ads)
+                                if self.shopping_ads:
+                                    st.session_state['shopping_ads'] = 'uploaded'
+                                    collect_telemetry(debug_info_shopping_ads)
+                                
+                
+                                
+                                #with st.expander("Debug information", icon="⚙"):
+                                #    st.write(debug_info)
+
+                                st.session_state['analyzing'] = False 
+                    except AttributeError:
+                        st.info("Please upload CSV or PDF files first.")
+                        hide_button() 
 
     def row1(self):
-        self.account_set_up = st.text_input("Account Set Up - Google Ads:", placeholder='Enter Account Set Up')
-        self.search_ads = st.checkbox("Search Ads - Google Ads/SEMRush")
-        self.display_ads = st.checkbox("Display Ads - Google Ads/SEMRush")
-        self.mobile_ads = st.checkbox("Mobile Ads - Google Ads")
-        self.video_ads = st.checkbox("Video Ads - Google Ads")
-        self.shopping_ads = st.checkbox("Shopping Ads - Google Ads/SEMRush")
-
-        self.process()  # Call process method to initiate processing
-
+            self.account_set_up = st.text_input("Account Set Up - Google Ads:", placeholder='Enter Account Set Up')
+            self.search_ads = st.checkbox("Search Ads - Google Ads/SEMRush")
+            self.display_ads = st.checkbox("Display Ads - Google Ads/SEMRush")
+            self.mobile_ads = st.checkbox("Mobile Ads - Google Ads")
+            self.video_ads = st.checkbox("Video Ads - Google Ads")
+            self.shopping_ads = st.checkbox("Shopping Ads - Google Ads/SEMRush")
+
+            '''
+            st.write("") # FOR THE HIDE BUTTON
+            st.write("") # FOR THE HIDE BUTTON
+            st.write("AI Analyst Output: ")
+            st.session_state['analyzing'] = False
+            st.write("") # FOR THE HIDE BUTTON'
+            '''
+            #analyze_button = st.button("Analyze", disabled=initialize_analyze_session())
+            self.process()
+            
 if __name__ == "__main__":
     st.set_page_config(layout="wide")
 
-    upload = uploadFile()  # Assuming this is another helper class handling file uploads
+upload = uploadFile()

pages/home.py

@@ -45,35 +45,38 @@ class DigitalFootprintDashboard:
             st.session_state.analysis_completed = False
         if 'uploading' not in st.session_state:
             st.session_state['uploading'] = False
+        if 'uploaded' not in st.session_state:
+            st.session_state['uploaded'] = False  # To track if uploading is completed
 
     async def create_row1(self):
         """Create the first row with four columns"""
         col1, col2, col3, col4, col5 = st.columns(5, border=True, gap="medium", vertical_alignment="top")
         
         with col1:
-            button_label = "Uploading..." if st.session_state['uploading'] else "Sync Data"
+            # Display upload status message
+            if st.session_state['uploading']:
+                st.info("Uploading...", icon="🔄")
+            elif st.session_state['uploaded']:
+                st.success("Uploaded successfully!", icon="✅")
+            
+            button_label = "Sync Data" if not st.session_state['uploading'] else "Uploading..."
             if st.button(button_label, key="sync_button", icon="🔄", use_container_width=True):
                 st.session_state['uploading'] = True
                 st.session_state['analyze'] = 'clicked'
                 
+                # Simulating uploading process (can be removed in actual case)
+                time.sleep(3)  # Simulate upload delay
+
                 st.session_state['uploading'] = False
+                st.session_state['uploaded'] = True  # Mark as uploaded successfully
             else:
                 st.session_state["analyze"] = ''
 
-            #self.upload_file_button = st.button("Sync Data", st.session_state['analyze'], icon="🔄", use_container_width=True)
-            
-            #if self.upload_file_button == True:
-            #    st.session_state["analyze"] = 'clicked'
-                #unhide_button()
-            #else:
-            #    st.session_state["analyze"] = ''
-            
             analyze_disabled = st.session_state.get('analyze') != 'clicked'
             if st.button("Analyze", key="analyze_button", icon="✨", use_container_width=True, disabled=analyze_disabled):
                 st.session_state.analysis_completed = False
                 st.switch_page("pages/analyzing_page.py")
             
-            
             self.client_summary = CientSummary()
             
         with col2:
@@ -106,7 +109,6 @@ class DigitalFootprintDashboard:
         
         with col5:
             st.write("## Website Structure")
-            #self.crawl = SeoOnCrawl(os.getenv('MODEL_On_Page_Analyst'))
             self.on_page = SeoOn(os.getenv('MODEL_On_Page_Analyst'))
             self.website_and_tools = WebsiteAndTools(os.getenv('MODEL_On_Page_Analyst'))
             self.lld_pm_ln = LLD_PM_LN(os.getenv('Model_LLD_PM_LN_ANALYST'))
@@ -117,24 +119,18 @@ class DigitalFootprintDashboard:
     async def create_row2(self):
         """Create the first row with four columns"""
         col1, col4 = st.columns(2, border=True, gap="medium", vertical_alignment="top")
-        # col1, col2, col3, col4 = st.columns(4, border=True, gap="medium", vertical_alignment="top")
         
         with col1:
             st.write("## Ads")
             self.sem_ppc = Sem_PPC(os.getenv('Model_SEM_PPC_Analyst'))
-        # with col2:
-        #     st.write("## Amazon")
-        #     self.amazon = Amazon(os.getenv('Model_SEM_PPC_Analyst'))
-        # with col3:
-        #     st.write("## eBay")
-        #     self.ebay = eBay(os.getenv('Model_SEM_PPC_Analyst'))
+        
         with col4:
             st.write("## Website Content")
             self.content = Content(os.getenv('Model_Content'))
         return col1, col4
     
     async def delete_button(self):
-        reset_button = st.button("RESET ALL",icon="🗑️", use_container_width=True)
+        reset_button = st.button("RESET ALL", icon="🗑️", use_container_width=True)
 
         if reset_button:
             clear_collection("df_data")
@@ -145,9 +141,8 @@ class DigitalFootprintDashboard:
         await self.create_row1()
         await self.create_row2()
         await self.delete_button()
-        #self.run_analysis()
 
 # Main execution
 if __name__ == "__main__":
     dashboard = DigitalFootprintDashboard()
-    asyncio.run(dashboard.main())
+    asyncio.run(dashboard.main())