Implement thread-safe handling for uploading client and SEM/PPC data with progress updates

classes/client_summary.py

@@ -1,10 +1,35 @@
 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):
@@ -23,43 +48,58 @@ class CientSummary:
         if 'target_market' not in st.session_state:
             st.session_state['target_market'] = ''
     
-    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 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
+                }
 
-                        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}
+                # Placeholder to display feedback
+                handler = ThreadSafeHandler(st.empty())
 
-                        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:")
+                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}")
 
-            if (self.client_summary or self.name or self.website) and session == 'clicked':
-                self.process()
+                # 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()
+
+    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:")
 
+        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()
+    upload = uploadFile()  # Assuming this is another helper class handling file uploads

classes/sem_ppc.py

@@ -1,161 +1,106 @@
 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()
-        '''
-        # 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'] = ''
+        # 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] = ''
 
     def process(self):
         session = st.session_state.analyze
-        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':
+        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):
                     try:
-                        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() 
+                        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()
 
     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")
-
-            '''
-            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()
-            
+        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
+
 if __name__ == "__main__":
     st.set_page_config(layout="wide")
 
-upload = uploadFile()
+    upload = uploadFile()  # Assuming this is another helper class handling file uploads

pages/home.py

@@ -140,20 +140,6 @@ class DigitalFootprintDashboard:
             clear_collection("df_data")
             clear_collection("df_response")
 
-    async def run_analysis(self):
-        result = await asyncio.gather(
-            self.gtmetrix.process(), 
-            self.backlinks.process(), 
-            self.keywords.process(), 
-            self.facebook.process(), 
-            self.instagram.process(), 
-            self.twitter.process(), 
-            self.youtube.process(), 
-            self.linkedin.process(), 
-            self.tiktok.process(), 
-        )
-        st.session_state.analyze = False
-        
     async def main(self):
         """Main method to run the dashboard"""
         await self.create_row1()