Add new analysis classes for LLD/PM/LN, Pull Through Offers, and Content; update website and tools integration

classes/Tiktok.py

@@ -155,9 +155,9 @@ class Tiktok:
             followers = {
                 'Tiktok Followers': self.tiktok_f if self.tiktok_f else 'N/A'
             }
-            tiktok_post = self.file_upload("Tiktok", "Tiktok Content post", "Tiktok")
+            #tiktok_post = self.file_upload("Tiktok", "Tiktok Content post", "Tiktok")
             
-            tiktok_post
+            #tiktok_post
            
             '''
             st.write("") # FOR THE HIDE BUTTON

classes/content.py

@@ -0,0 +1,81 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+
+class Content:
+    def __init__(self, model_url):
+        self.uploaded_files = []
+        self.file_dict = {}
+        self.file_gt = {}
+        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()
+
+        if 'content_in_the_website' not in st.session_state:
+            st.session_state['content_in_the_website'] = ''
+        if 'content_outside_the_website' not in st.session_state:
+            st.session_state['content_outside_the_website'] = ''
+    
+    def process(self):
+                session = st.session_state.analyze
+
+                if (self.content_in_the_website or self.content_outside_the_website) and session == 'clicked':
+                    with st.spinner('SEO On Page Analyst...', show_time=True):
+                        st.write('')
+                        content_in_the_website = ""
+                        content_outside_the_website = ""
+                        try:
+                            content_in_the_website += f"\nContent in the Website: {self.content_in_the_website}"
+                        except KeyError:
+                            pass
+                        try:
+                            content_outside_the_website += f"\nContent outside the Website: {self.content_outside_the_website}"
+                        except KeyError:
+                            pass
+
+                        debug_info_content_in_the_website = {'data_field' : 'Content in the Website', 'result': content_in_the_website}
+                        debug_info_content_outside_the_website = {'data_field' : 'Content outside the Website', 'result': content_outside_the_website}
+
+                        if self.content_in_the_website:
+                            st.session_state['content_in_the_website'] = 'uploaded'
+                            collect_telemetry(debug_info_content_in_the_website)
+                        if self.content_outside_the_website:
+                            st.session_state['content_outside_the_website'] = 'uploaded'
+                            collect_telemetry(debug_info_content_outside_the_website)
+                        
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+
+
+                        st.session_state['analyzing'] = False
+                        try:
+                            self.file_dict.popitem()
+                        except KeyError:
+                            pass
+                        
+    def row1(self):
+            self.content_in_the_website = st.text_input("Content in the Website (Website Content)", placeholder='Enter Content in the Website')
+            self.content_outside_the_website = st.text_input("Content outside the Website (Website Content)", placeholder='Enter Content outside the Website')
+
+            self.process()
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/lld_pm_ln.py

@@ -0,0 +1,73 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+
+class LLD_PM_LN:
+    def __init__(self, model_url):
+        self.uploaded_files = []
+        self.file_dict = {}
+        self.file_gt = {}
+        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()
+
+       
+        if 'lead_generation_mechanism' not in st.session_state:
+            st.session_state['lead_generation_mechanism'] = ''
+    
+    def process(self):
+                session = st.session_state.analyze
+                if (self.lead_generation_mechanism) and session == 'clicked':
+                    lead_generation_mechanism = ""
+                    with st.spinner('SEO On Page Analyst...', show_time=True):
+                        st.write('')
+
+                        try:
+                            lead_generation_mechanism += f"\nLead Generation Mechanism: {self.lead_generation_mechanism}"
+                        except KeyError:
+                            pass
+
+                        debug_info_lead_generation_mechanism = {'data_field' : 'Lead Generation Mechanism', 'result': lead_generation_mechanism}
+                       
+             
+                        if self.lead_generation_mechanism:
+                            st.session_state['lead_generation_mechanism'] = 'uploaded'
+                            collect_telemetry(debug_info_lead_generation_mechanism)
+                        
+                        
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+
+
+                        st.session_state['analyzing'] = False
+                        try:
+                            self.file_dict.popitem()
+                        except KeyError:
+                            pass
+                        
+    def row1(self):        
+            self.lead_generation_mechanism = st.text_input("Lead Generation Mechanism - Business Context (Lead Generation & Lead Nurturing):", placeholder='Enter Lead Generation Mechanism')
+            st.session_state['analyzing'] = False
+            
+            self.process()
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/pull_through_offers.py

@@ -0,0 +1,69 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+
+class PullThroughOffers:
+    def __init__(self, model_url):
+        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()
+
+        if 'pull_through_offers' not in st.session_state:
+            st.session_state['pull_through_offers'] = ''
+    
+    def process(self):
+                session = st.session_state.analyze
+                if (self.pull_through_offers) and session == 'clicked':
+                    pull_through_offers = ""
+                    with st.spinner('SEO On Page Analyst...', show_time=True):
+                        st.write('')
+                        
+                        try:
+                            pull_through_offers += f"\nPull Through Offers: {self.pull_through_offers}"
+                        except KeyError:
+                            pass
+                        
+
+                        
+                        debug_info_pull_through_offers = {'data_field' : 'Pull through offers', 'result': pull_through_offers}
+                        
+
+                        if self.pull_through_offers:
+                            st.session_state['pull_through_offers'] = 'uploaded'
+                            collect_telemetry(debug_info_pull_through_offers)
+                       
+                        
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+
+
+                        st.session_state['analyzing'] = False
+                                             
+    def row1(self):
+            
+            self.pull_through_offers = st.text_input("Pull through offers (Business Context)", placeholder='Enter Pull through offers')
+            
+            st.session_state['analyzing'] = False
+
+            self.process()
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/response_content.py

@@ -0,0 +1,146 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+from pymongo import MongoClient
+import json
+from helper.data_field import data_field
+from helper.upload_response import upload_response
+
+class Content:
+    def __init__(self, model_url):
+        self.uploaded_files = []
+        self.file_dict = {}
+        self.file_gt = {}
+        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'''
+    
+    def request_model(self, payload_txt, headers):
+        response = requests.post(self.model_url, json=payload_txt, headers=headers)
+        response.raise_for_status()
+        
+        output = response.json()
+        text = output["outputs"][0]["outputs"][0]["results"]["text"]["data"]["text"]
+        text = json.loads(text)
+        #st.write(text)
+        return text
+    
+    def fetch_data(self, data_field):
+        mongodb_uri = os.getenv("MONGODB_URI")
+        myclient = MongoClient(mongodb_uri)
+        mydb = myclient.get_database()
+        mycol = mydb["df_data"]
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
+        x = x["result"]
+        return x
+
+    def process(self):
+                with st.spinner('Content Analyst...', show_time=True):
+                        st.write('')       
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}                                     
+                        try:
+                            payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
+                            payload_txt_model = self.request_model(payload_txt, headers)
+                            debug_info = {'data_field' : 'Content Analyst', 'result': payload_txt_model}
+                            upload_response(debug_info)
+
+                            st.session_state['content_in_the_website'] = ''  
+                            st.session_state['content_outside_the_website'] = ''  
+
+                            count = 0
+                        except Exception as e:
+                            pass
+                       
+                    
+                        #end_time = time.time()
+                        #time_lapsed = end_time - start_time
+
+                        #debug_info = {'data_field' : 'GT Metrix', 'result': result}
+                        
+                        
+                        '''
+                        debug_info = {#'analyst': self.analyst_name,
+                                      'url_uuid': self.model_url.split("-")[-1],
+                                      'time_lapsed' : time_lapsed, 
+                                    'crawl_file': [file.name for file in self.uploaded_files] if self.uploaded_files else ['Not available'],
+                                      'gt_metrix': [file.name for file in self.gtmetrix] if self.gtmetrix else ['Not available'],
+                                      'payload': payload_txt, 
+                                      'result': result}
+                        
+                        if self.gtmetrix:
+                            collect_telemetry(debug_info)
+                        '''
+ 
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+                        
+
+                        st.session_state['analyzing'] = False
+                        try:
+                            self.file_dict.popitem()
+                        except KeyError:
+                            pass
+                        
+    def row1(self):
+            st.session_state['analyzing'] = False
+            self.payload = ""
+            count = 0
+
+            try:
+                session_content_in_the_website = st.session_state['content_in_the_website']
+                if session_content_in_the_website == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Content in the Website")
+            except Exception as e:
+                pass
+            try:
+                session_content_outside_the_website = st.session_state['content_outside_the_website']
+                if session_content_outside_the_website == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Content outside the Website")
+            except Exception as e:
+                pass
+            
+            if count >= 1:
+                self.process()
+                 
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/response_lld_pm_ln.py

@@ -0,0 +1,130 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+from pymongo import MongoClient
+import json
+from helper.data_field import data_field
+from helper.upload_response import upload_response
+
+class LLD_PM_LN:
+    def __init__(self, model_url):
+        self.uploaded_files = []
+        self.file_dict = {}
+        self.file_gt = {}
+        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'''
+    
+    def request_model(self, payload_txt, headers):
+        response = requests.post(self.model_url, json=payload_txt, headers=headers)
+        response.raise_for_status()
+        output = response.json()
+        #st.write(output)
+        text = output["outputs"][0]["outputs"][0]["results"]["text"]["data"]["text"]
+        #st.write(text)
+        text = json.loads(text)
+        #st.write(text)
+        return text
+    
+    def fetch_data(self, data_field):
+        mongodb_uri = os.getenv("MONGODB_URI")
+        myclient = MongoClient(mongodb_uri)
+        mydb = myclient.get_database()
+        mycol = mydb["df_data"]
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
+        x = x["result"]
+        return x
+
+    def process(self):
+                with st.spinner('LLD/PM/LN Analyst...', show_time=True):
+                        st.write('')       
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}                                     
+                        try:
+                            payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
+                            payload_txt_model = self.request_model(payload_txt, headers)
+                            debug_info = {'data_field' : 'LLD/PM/LN Analyst', 'result': payload_txt_model}
+                            upload_response(debug_info)
+
+                            st.session_state['lead_generation_mechanism'] = ''  
+                            count = 0
+                        except Exception as e:
+                            pass
+                       
+                    
+                        #end_time = time.time()
+                        #time_lapsed = end_time - start_time
+
+                        #debug_info = {'data_field' : 'GT Metrix', 'result': result}
+                        
+                        
+                        '''
+                        debug_info = {#'analyst': self.analyst_name,
+                                      'url_uuid': self.model_url.split("-")[-1],
+                                      'time_lapsed' : time_lapsed, 
+                                    'crawl_file': [file.name for file in self.uploaded_files] if self.uploaded_files else ['Not available'],
+                                      'gt_metrix': [file.name for file in self.gtmetrix] if self.gtmetrix else ['Not available'],
+                                      'payload': payload_txt, 
+                                      'result': result}
+                        
+                        if self.gtmetrix:
+                            collect_telemetry(debug_info)
+                        '''
+ 
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+                                                               
+    def row1(self):
+            st.session_state['analyzing'] = False
+            self.payload = ""
+            count = 0
+            try:
+                session_lead_generation_mechanism = st.session_state['lead_generation_mechanism']
+                if session_lead_generation_mechanism == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Lead Generation Mechanism")
+
+            except Exception as e:
+                pass
+            if count >= 1:
+                self.process()
+                 
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/response_pull_through_offers.py

@@ -0,0 +1,136 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+from helper.telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.button_behaviour import hide_button, unhide_button
+from helper.initialize_analyze_session import initialize_analyze_session
+import pandas as pd
+from pymongo import MongoClient
+import json
+from helper.data_field import data_field
+from helper.upload_response import upload_response
+
+class PullThroughOffers:
+    def __init__(self, model_url):
+        self.uploaded_files = []
+        self.file_dict = {}
+        self.file_gt = {}
+        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'''
+    
+    def request_model(self, payload_txt, headers):
+        response = requests.post(self.model_url, json=payload_txt, headers=headers)
+        response.raise_for_status()
+        output = response.json()
+        text = output["outputs"][0]["outputs"][0]["results"]["text"]["data"]["text"]
+        #st.write(text)
+        #text = json.loads(text)
+        #st.write(text)
+        return text
+    
+    def fetch_data(self, data_field):
+        mongodb_uri = os.getenv("MONGODB_URI")
+        myclient = MongoClient(mongodb_uri)
+        mydb = myclient.get_database()
+        mycol = mydb["df_data"]
+        
+        # Sort by timestamp field in descending order
+        x = mycol.find_one(
+            {"data_field": data_field},
+            sort=[("timestamp", -1)]  
+        )
+        
+        x = x["result"]
+        return x
+
+    def process(self):
+                with st.spinner('Pull through offers...', show_time=True):
+                        st.write('')       
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}                                     
+                        try:
+                            payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
+                            payload_txt_model = self.request_model(payload_txt, headers)
+                            debug_info = {'data_field' : 'Pull through offers Analyst', 'result': payload_txt_model}
+                            upload_response(debug_info)
+
+                            st.session_state['pull_through_offers'] = ''
+                            count = 0
+                        except Exception as e:
+                            pass
+                       
+                    
+                        #end_time = time.time()
+                        #time_lapsed = end_time - start_time
+
+                        #debug_info = {'data_field' : 'GT Metrix', 'result': result}
+                        
+                        
+                        '''
+                        debug_info = {#'analyst': self.analyst_name,
+                                      'url_uuid': self.model_url.split("-")[-1],
+                                      'time_lapsed' : time_lapsed, 
+                                    'crawl_file': [file.name for file in self.uploaded_files] if self.uploaded_files else ['Not available'],
+                                      'gt_metrix': [file.name for file in self.gtmetrix] if self.gtmetrix else ['Not available'],
+                                      'payload': payload_txt, 
+                                      'result': result}
+                        
+                        if self.gtmetrix:
+                            collect_telemetry(debug_info)
+                        '''
+ 
+                            
+                        #with st.expander("Debug information", icon="⚙"):
+                        #    st.write(debug_info)
+                        
+
+                        st.session_state['analyzing'] = False
+                        try:
+                            self.file_dict.popitem()
+                        except KeyError:
+                            pass
+                        
+    def row1(self):
+            st.session_state['analyzing'] = False
+            self.payload = ""
+            count = 0
+            try:
+                session_pull_through_offers = st.session_state['pull_through_offers']
+                if session_pull_through_offers == 'uploaded':
+                    count += 1
+                    self.payload += self.fetch_data("Pull through offers")
+            except Exception as e:
+                pass
+            
+            if count >= 1:
+                self.process()
+                 
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/response_website_and_tools.py

@@ -72,8 +72,7 @@ class WebsiteAndTools:
     def process(self):
                 with st.spinner('Website and Tools...', show_time=True):
                         st.write('')       
-                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}
-                                         
+                        headers = {"Content-Type": "application/json", "x-api-key": f"{os.getenv('x-api-key')}"}                                     
                         try:
                                 payload_txt = {"input_value": self.payload, "output_type": "text", "input_type": "chat"}
                                 payload_txt_model = self.request_model(payload_txt, headers)
@@ -88,10 +87,12 @@ class WebsiteAndTools:
                                 st.session_state['first_meaningful_paint'] = ''
                                 st.session_state['web_analytics'] = ''
                                 st.session_state['client_relations_management_system'] = ''
-                                st.session_state['lead_generation_mechanism'] = ''
+                                #st.session_state['lead_generation_mechanism'] = ''
                                 count = 0
                         except Exception as e:
                              pass
+
+
                         #end_time = time.time()
                         #time_lapsed = end_time - start_time
 
@@ -125,9 +126,9 @@ class WebsiteAndTools:
     def row1(self):
             st.session_state['analyzing'] = False
             self.payload = ""
+            
             count = 0
             try:
-                payload = ""
                 session_website_responsiveness = st.session_state['website_responsiveness']
                 if session_website_responsiveness == 'uploaded':
                     count += 1
@@ -191,13 +192,8 @@ class WebsiteAndTools:
                     self.payload += self.fetch_data("Client Relations Management System")
             except Exception as e:
                 pass
-            try:
-                session_lead_generation_mechanism = st.session_state['lead_generation_mechanism']
-                if session_lead_generation_mechanism == 'uploaded':
-                    count += 1
-                    self.payload += self.fetch_data("Lead Generation Mechanism")
-            except Exception as e:
-                pass
+            
+            
             if count >= 1:
                 self.process()
                  

classes/website_and_tools.py

@@ -55,48 +55,11 @@ class WebsiteAndTools:
             st.session_state['web_analytics'] = ''
         if 'client_relations_management_system' not in st.session_state:
             st.session_state['client_relations_management_system'] = ''
-        if 'lead_generation_mechanism' not in st.session_state:
-            st.session_state['lead_generation_mechanism'] = ''
-        
-        
-    def request_model(self, payload_txt):
-        response = requests.post(self.model_url, json=payload_txt)
-        response.raise_for_status()
-        output = response.json()
-        
-        categories = []
-        remarks = []
-
-        for key, value in output.items():
-            if key == 'json':
-                for item in value:
-                    categories.append(item.get('elements', 'N/A').replace('_', ' ').title())
-                    remarks.append(item.get('remarks', 'N/A'))
-
-        output = ""
-        for i in range(len(categories)):
-            output += f"\n\n---\n **Category:** {categories[i]}"
-            output += f"\n\n **Remarks:** {remarks[i]}\n\n"
-        
-        data = {
-            "Category": [str(category) for category in categories],
-            "Remarks": [str(footprint) for footprint in remarks],
-        }
-        df_output = pd.DataFrame(data)
-        '''
-        with st.expander("AI Analysis", expanded=True, icon="🤖"):
-            st.table(df_output.style.set_table_styles(
-                [{'selector': 'th:first-child, td:first-child', 'props': [('width', '20px')]},
-                {'selector': 'th, td', 'props': [('width', '150px'), ('text-align', 'center')]}]
-            ).set_properties(**{'text-align': 'center'}))
-        '''
-
-        return output
     
     def process(self):
                 session = st.session_state.analyze
                 start_time = time.time()
-                if (self.website_responsiveness or self.content_management_system or self.SSL_certificate or self.web_analytics or self.client_relations_management_system or self.lead_generation_mechanism or self.mobile_responsiveness or self.mobile_loading_speed or self.desktop_loading_speed) and session == 'clicked':
+                if (self.website_responsiveness or self.content_management_system or self.SSL_certificate or self.web_analytics or self.client_relations_management_system or self.mobile_responsiveness or self.mobile_loading_speed or self.desktop_loading_speed) and session == 'clicked':
                     website_responsiveness = ""
                     content_management_system = ""
                     SSL_certificate = ""
@@ -106,7 +69,7 @@ class WebsiteAndTools:
                     web_analytics = ""
                     client_relations_management_system = ""
                     mobile_loading_speed = ""
-                    lead_generation_mechanism = ""
+        
                     with st.spinner('SEO On Page Analyst...', show_time=True):
                         st.write('')
                         '''
@@ -164,11 +127,6 @@ class WebsiteAndTools:
                             client_relations_management_system += f"\nClient Relations Management System: {self.client_relations_management_system}"
                         except KeyError:
                             pass
-                        try:
-                            lead_generation_mechanism += f"\nLead Generation Mechanism: {self.lead_generation_mechanism}"
-                        except KeyError:
-                            pass
-
                         
                         # OUTPUT FOR WEBSITE RESPONSIVENESS
                         payload_txt_website_responsiveness = {"question": website_responsiveness}
@@ -191,8 +149,6 @@ class WebsiteAndTools:
                         #result_client_relations_management_system = self.request_model(client_relations_management_system)
                         
                         # OUTPUT FOR LEAD GENERATION MECHANISM
-                        payload_txt_lead_generation_mechanism = {"question": lead_generation_mechanism}
-                        #result_lead_generation_mechanism = self.request_model(lead_generation_mechanism)
 
                         # OUTPUT FOR SEO ANALYST
                         #payload_txt = {"question": combined_text}
@@ -208,7 +164,7 @@ class WebsiteAndTools:
                         debug_info_mobile_loading_speed = {'data_field' : 'Mobile Loading Speed', 'result': mobile_loading_speed}
                         debug_info_web_analytics = {'data_field' : 'Web Analytics', 'result': web_analytics}
                         debug_info_client_relations_management_system = {'data_field' : 'Client Relations Management System', 'result': client_relations_management_system}
-                        debug_info_lead_generation_mechanism = {'data_field' : 'Lead Generation Mechanism', 'result': lead_generation_mechanism}
+
                         '''
                         debug_info = {#'analyst': self.analyst_name,
                                       'url_uuid': self.model_url.split("-")[-1],
@@ -245,9 +201,7 @@ class WebsiteAndTools:
                         if self.client_relations_management_system:
                             st.session_state['client_relations_management_system'] = 'uploaded'
                             collect_telemetry(debug_info_client_relations_management_system)
-                        if self.lead_generation_mechanism:
-                            st.session_state['lead_generation_mechanism'] = 'uploaded'
-                            collect_telemetry(debug_info_lead_generation_mechanism)
+
                             
                         #with st.expander("Debug information", icon="⚙"):
                         #    st.write(debug_info)
@@ -279,8 +233,7 @@ class WebsiteAndTools:
             self.mobile_loading_speed = st.text_input("Mobile Loading Speed - GTMetrix:", placeholder='Enter Mobile Loading Speed')
             self.web_analytics = st.text_input("Web Analytics - BuiltWith (GA4):", placeholder='Enter Web Analytics')
             self.client_relations_management_system = st.text_input("Client Relations Management System - BuiltWith:", placeholder='Enter Client Relations Management System')
-            self.lead_generation_mechanism = st.text_input("Lead Generation Mechanism - Business Context (Lead Generation & Lead Nurturing):", placeholder='Enter Lead Generation Mechanism')
-
+            
             #st.write("") # FOR THE HIDE BUTTON
             #st.write("") # FOR THE HIDE BUTTON
             #st.write("AI Analyst Output: ")

pages/analyzing_page.py

@@ -7,6 +7,9 @@ from classes.response_on_page import SeoOn
 from classes.response_website_and_tools import WebsiteAndTools
 from classes.response_seo import Seo
 from classes.response_social_media import SocialMedia
+from classes.response_lld_pm_ln import LLD_PM_LN
+from classes.response_pull_through_offers import PullThroughOffers
+from classes.response_content import Content
 
 def run_analysis():
     # Placeholders for status updates
@@ -15,6 +18,9 @@ def run_analysis():
     website_and_tools_status = st.empty()
     seo_status = st.empty()
     social_media_status = st.empty()
+    lld_pm_ln_status = st.empty()
+    pull_through_offers_status = st.empty()
+    content_status = st.empty()
     # Function to run SEO Off Page Analysis
     def run_off_page_analysis():
         try:
@@ -65,13 +71,43 @@ def run_analysis():
         except Exception as e:
             social_media_status.error(f"Social Media Analysis failed: {e}")
             return None
-        
+    def run_lld_pm_ln():
+        try:
+            lld_pm_ln_status.info("Starting LLD/PM/LN Analysis...")
+            result = LLD_PM_LN(os.getenv('Model_LLD_PM_LN_ANALYST'))
+            lld_pm_ln_status.success("LLD/PM/LN completed successfully.")
+            return result
+        except Exception as e:
+            lld_pm_ln_status.error(f"LLD/PM/LN Analysis failed: {e}")
+            return None
+    def run_pull_through_offers():
+        try:
+            pull_through_offers_status.info("Starting Pull through offer Analysis...")
+            result = PullThroughOffers(os.getenv('Model_Pull_Through_Offers_Analyst'))
+            pull_through_offers_status.success("Pull through offer completed successfully.")
+            return result
+        except Exception as e:
+            pull_through_offers_status.error(f"Pull through offer Analysis failed: {e}")
+            return None
+    def run_content():
+        try:
+            content_status.info("Starting Content Analysis...")
+            result = Content(os.getenv('Model_Content'))
+            content_status.success("Content Analysis completed successfully.")
+            return result
+        except Exception as e:
+            content_status.error(f"Content Analysis failed: {e}")
+            return None
+    
     # Create threads for concurrent execution
     off_page_thread = threading.Thread(target=run_off_page_analysis)
     on_page_thread = threading.Thread(target=run_on_page_analysis)
     website_and_tools_thread = threading.Thread(target=run_website_and_tools_analysis)
     seo_thread = threading.Thread(target=run_seo_analysis)
     social_media_thread = threading.Thread(target=run_social_media_analysis)
+    llm_pm_ln_thread = threading.Thread(target=run_lld_pm_ln)
+    pull_through_offers_thread = threading.Thread(target=run_pull_through_offers)
+    content_thread = threading.Thread(target=run_content)
 
     # Attach Streamlit context to threads
     add_script_run_ctx(off_page_thread)
@@ -79,6 +115,9 @@ def run_analysis():
     add_script_run_ctx(website_and_tools_thread)
     add_script_run_ctx(seo_thread)
     add_script_run_ctx(social_media_thread)
+    add_script_run_ctx(llm_pm_ln_thread)
+    add_script_run_ctx(pull_through_offers_thread)
+    add_script_run_ctx(content_thread)
 
     # Start threads
     off_page_thread.start()
@@ -86,6 +125,9 @@ def run_analysis():
     website_and_tools_thread.start()
     seo_thread.start()
     social_media_thread.start()
+    llm_pm_ln_thread.start()
+    pull_through_offers_thread.start()
+    content_thread.start()
 
     # Wait for threads to complete
     off_page_thread.join()
@@ -93,7 +135,10 @@ def run_analysis():
     website_and_tools_thread.join()
     seo_thread.join()
     social_media_thread.join()
-    
+    llm_pm_ln_thread.join()
+    pull_through_offers_thread.join()
+    content_thread.join()
+
     st.success("🎉 All analyses completed!") # Final success message
     # --- Display Button After Completion ---
     if st.button("View Results"):

pages/home.py

@@ -13,6 +13,9 @@ from classes.Linkedin import Linkedin
 from classes.Tiktok import Tiktok
 from classes.website_and_tools import WebsiteAndTools
 from classes.client_summary import CientSummary
+from classes.pull_through_offers import PullThroughOffers
+from classes.lld_pm_ln import LLD_PM_LN
+from classes.content import Content
 import asyncio
 import time
 from helper.upload_button import hide_button, unhide_button
@@ -86,6 +89,9 @@ class DigitalFootprintDashboard:
             #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'))
+            self.pull_through_offers = PullThroughOffers(os.getenv('Model_Pull_Through_Offers_Analyst'))
+            self.content = Content(os.getenv('Model_Content'))
 
         return col1, col2, col3, col4