refactor: update analyst page navigation and import structure; add file upload functionality

app.py

@@ -81,7 +81,7 @@ def row2():
         st.header("Analyst 7")
         st.write("")
         if st.button("Load Analyst", key=7, disabled=True):
-            st.switch_page("pages/Traffic_EDA.py")
+            st.switch_page("pages/image.py")
     
     with col4:
         st.header("Analyst 8")

classes/Seo.py

@@ -0,0 +1,234 @@
+from gradio import JSON
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import pandas as pd
+import pymupdf
+import time
+import chardet
+import json
+from telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+from helper.upload_traffic import upload_traffic
+
+class SeoAnalyst:
+    def __init__(self, model_url, analyst_name, data_src, analyst_description):
+        self.uploaded_files = []
+        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.initialize_analyze_session()
+        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("./app.py")
+        except Exception:
+            pass
+    
+    def request_model(self, payload_txt):
+        response = requests.post(self.model_url, json=payload_txt)
+        response.raise_for_status()
+        output = response.json()
+        output_dict = {key: value for key, value in output.items()}
+        output_str = json.dumps(output_dict, indent=8, sort_keys=False)
+        
+        categories = []
+        current_footprint = []
+        number_of_backlinks = []
+
+        for key, value in output.items():
+            if key == 'json':
+                for item in value:
+                    categories.append(item.get('category', 'N/A').replace('_', ' ').title())
+                    current_footprint.append(item.get('current_footprint', 'N/A'))
+                    number_of_backlinks.append(item.get('best_of_breed_solution', 'N/A'))    
+
+        output = ""
+        for i in range(len(categories)):
+            output += f"\n\n---\n **Category:** {categories[i]}"
+            output += f"\n\n **Current Footprint:** {current_footprint[i]}\n\n"
+            output += f"**Number of Backlinks:** {number_of_backlinks[i]}"
+        
+        return output
+    
+    def initialize_analyze_session(self):
+        if 'analyzing' not in st.session_state:
+            st.session_state['analyzing'] = False
+        return st.session_state.get('analyzing', False)
+    
+    def hide_button(self):
+        if st.session_state['analyzing'] == True:
+            st.markdown(
+                """
+                    <style>
+                    .element-container:nth-of-type(5) button {
+                    display: none;
+                    }
+                    </style>
+                """,
+                unsafe_allow_html=True,
+            )
+        elif st.session_state['analyzing'] == False:
+            st.markdown(
+            """
+                <style>
+                element-container:nth-of-type(5) button {
+                display: inline;
+                }
+                </style>
+            """,
+            unsafe_allow_html=True,
+        )
+    
+    def detect_encoding(self, uploaded_file):
+        result = chardet.detect(uploaded_file.read(100000))
+        uploaded_file.seek(0)  # Reset file pointer to the beginning
+        return result['encoding']
+
+    def keyword_ranking(self, df_seo):
+        keyword_ranking = df_seo
+        st.session_state['keyword_ranking'] = keyword_ranking
+
+        keywords_ranking_sorted = keyword_ranking.sort_values("Position", ascending=True)
+
+        keywords_ranking_top_10 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 10].shape[0]
+        keywords_ranking_top_100 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 100].shape[0]
+
+        keyword_ranking = {
+            'Keyword_top_10': keywords_ranking_top_10,
+            'Keyword_top_100': keywords_ranking_top_100
+        }
+        st.session_state['keyword_ranking'] = keyword_ranking
+    def traffic_files(self, df):
+        traffic_channels = df
+        traffic_channels.rename(columns={traffic_channels.columns[0]: 'date'}, inplace=True)
+        traffic_channels['date'] = pd.to_datetime(traffic_channels['date'], format='mixed')
+
+        traffic_channels_sort = traffic_channels.sort_values("date", ascending=False)
+
+        organic_traffic = traffic_channels_sort['Organic Search'].values[0]
+        paid_traffic = traffic_channels_sort['Paid Search'].values[0]
+        direct_traffic = traffic_channels_sort['Direct'].values[0]
+        referral_traffic = traffic_channels_sort['Referral'].values[0]
+
+        st.session_state['organic_traffic'] = organic_traffic
+        st.session_state['paid_traffic'] = paid_traffic
+        st.session_state['direct_traffic'] = direct_traffic
+        st.session_state['referral_traffic'] = referral_traffic
+   
+    def row1(self):
+        col1, col2 = st.columns(2, gap="medium")
+        with col1:
+            st.write("") # FOR SPACING
+            st.write(self.data_src)
+            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
+            if self.uploaded_files:
+                upload.multiple_upload_file(self.uploaded_files)
+                self.file_dict = upload.file_dict
+
+            self.uploaded_file = st.file_uploader("Upload Traffic Files CSV", type='csv')
+            if self.uploaded_file:
+                encoding = self.detect_encoding(self.uploaded_file)
+                st.session_state['df'] = pd.read_csv(self.uploaded_file, encoding=encoding, low_memory=False)
+
+            st.write("") # FOR THE HIDE BUTTON
+            self.uploaded_file_seo = st.file_uploader("Upload SEO Keywords CSV", type='csv', key=3)
+            if self.uploaded_file_seo:
+                encoding_seo = self.detect_encoding(self.uploaded_file_seo)
+                st.session_state['df_seo'] = pd.read_csv(self.uploaded_file_seo, encoding=encoding_seo, low_memory=False)
+            
+        with col2:
+            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=self.initialize_analyze_session())
+            start_time = time.time()
+            if analyze_button:
+                st.session_state['analyzing'] = True 
+                self.hide_button()
+                if self.uploaded_files:
+                    combined_text = ""
+                    with st.spinner('Analyzing...', show_time=True):
+                        st.write('')
+                        for file_info in st.session_state['uploaded_files'].values():
+                            if file_info['type'] == 'pdf':
+                                combined_text += file_info['content'] + "\n"
+                            elif file_info['type'] == 'csv':
+                                combined_text += file_info['content'].to_csv(index=True) + "\n"
+
+                        # INITIALIZING SESSIONS
+                        try:
+                            df = st.session_state['df']
+                            df_seo = st.session_state['df_seo']
+                            self.keyword_ranking(df_seo)
+                            self.traffic_files(df)
+                            keyword_ranking = st.session_state['keyword_ranking']    
+                            organic_traffic = st.session_state['organic_traffic']
+                            paid_traffic = st.session_state['paid_traffic']
+                            direct_traffic = st.session_state['direct_traffic']
+                            referral_traffic = st.session_state['referral_traffic']
+
+                            combined_text += df.to_csv(index=True)
+                            combined_text += f"\nKeyword Ranking Top 10: {keyword_ranking['Keyword_top_10']}"
+                            combined_text += f"\nKeyword Ranking Top 100: {keyword_ranking['Keyword_top_100']}\n\n"
+                            
+                            
+                            combined_text += df_seo.to_csv(index=True)
+                            combined_text += f"\nOrganic Traffic: {organic_traffic}"
+                            combined_text += f"\nPaid Traffic: {paid_traffic}"
+                            combined_text += f"\nDirect Traffic: {direct_traffic}"
+                            combined_text += f"\nReferral Traffic: {referral_traffic}"
+                        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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files'],],'payload': payload_txt, 'result': result}
+                        
+                        collect_telemetry(debug_info)
+                        
+                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
+                            st.write(debug_info.pop("result"))
+                            
+                        with st.expander("Debug information", icon="⚙"):
+                            st.write(debug_info)
+
+                        for df in st.session_state.keys():
+                            del st.session_state[df]
+                        for df_seo in st.session_state.keys():
+                            del st.session_state[df_seo]
+
+                        st.session_state['analyzing'] = False
+                else:
+                    st.info("Please upload CSV or PDF files first.")
+                    st.session_state['analyzing'] = False
+                    self.hide_button()       
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()
+traffic = upload_traffic()

classes/Seo_Off_Page.py

@@ -0,0 +1,157 @@
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+import chardet
+from telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+
+class SeoOffPageAnalyst:
+    def __init__(self, model_url, analyst_name, data_src, analyst_description):
+        self.uploaded_files = []
+        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.initialize_analyze_session()
+        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("./app.py")
+        except Exception:
+            pass
+    
+    def request_model(self, payload_txt):
+        response = requests.post(self.model_url, json=payload_txt)
+        response.raise_for_status()
+        output = response.json()
+        
+        categories = []
+        current_footprint = []
+        number_of_backlinks = []
+
+        for key, value in output.items():
+            if key == 'json':
+                for item in value:
+                    categories.append(item.get('elements', 'N/A').replace('_', ' ').title())
+                    current_footprint.append(item.get('remarks', 'N/A'))
+                    number_of_backlinks.append(item.get('count', 'N/A'))
+
+        output = ""
+        for i in range(len(categories)):
+            output += f"\n\n---\n **Category:** {categories[i]}"
+            output += f"\n\n **Remarks:** {current_footprint[i]}\n\n"
+            output += f"**Count:** {number_of_backlinks[i]}"
+        
+        return output
+    
+    def initialize_analyze_session(self):
+        if 'analyzing' not in st.session_state:
+            st.session_state['analyzing'] = False
+        return st.session_state.get('analyzing', False)
+    
+    def hide_button(self):
+        if st.session_state['analyzing'] == True:
+            st.markdown(
+                """
+                    <style>
+                    .element-container:nth-of-type(5) button {
+                    display: none;
+                    }
+                    </style>
+                """,
+                unsafe_allow_html=True,
+            )
+        elif st.session_state['analyzing'] == False:
+            st.markdown(
+            """
+                <style>
+                element-container:nth-of-type(5) button {
+                display: inline;
+                }
+                </style>
+            """,
+            unsafe_allow_html=True,
+        )
+    
+    def detect_encoding(self, uploaded_file):
+        result = chardet.detect(uploaded_file.read(100000))
+        uploaded_file.seek(0)  # Reset file pointer to the beginning
+        return result['encoding']
+
+   
+    def row1(self):
+        col1, col2 = st.columns(2, gap="medium")
+        with col1:
+            st.write("") # FOR SPACING
+            st.write(self.data_src)
+            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
+            if self.uploaded_files:
+                upload.multiple_upload_file(self.uploaded_files)
+                
+        with col2:
+            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=self.initialize_analyze_session())
+            start_time = time.time()
+            if analyze_button:
+                st.session_state['analyzing'] = True 
+                self.hide_button()
+                if self.uploaded_files:
+                    combined_text = ""
+                    with st.spinner('Analyzing...', show_time=True):
+                        st.write('')
+                        for file_info in st.session_state['uploaded_files'].values():
+                            if file_info['type'] == 'pdf':
+                                combined_text += file_info['content'] + "\n"
+                            elif file_info['type'] == 'csv':
+                                combined_text += file_info['content'].to_csv(index=True) + "\n"
+                        
+                        # 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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files']],'payload': payload_txt, 'result': result}
+                        
+                        collect_telemetry(debug_info)
+                        
+                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
+                            st.write(debug_info.pop("result"))
+                            
+                        with st.expander("Debug information", icon="⚙"):
+                            st.write(debug_info)
+
+                        st.session_state['analyzing'] = False
+                        
+                        
+                else:
+                    st.info("Please upload CSV or PDF files first.")
+                    st.session_state['analyzing'] = False
+                    self.hide_button()       
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

classes/Seo_On_Page.py

@@ -0,0 +1,160 @@
+from gradio import JSON
+import streamlit as st
+import requests
+from dotenv import load_dotenv
+import os
+import time
+import chardet
+from telemetry import collect_telemetry
+from helper.upload_File import uploadFile
+
+class SeoOnPageAnalyst:
+    def __init__(self, model_url, analyst_name, data_src, analyst_description):
+        self.uploaded_files = []
+        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.initialize_analyze_session()
+        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("./app.py")
+        except Exception:
+            pass
+    
+    def request_model(self, payload_txt):
+        response = requests.post(self.model_url, json=payload_txt)
+        response.raise_for_status()
+        output = response.json()
+        
+        categories = []
+        current_footprint = []
+        number_of_backlinks = []
+
+        for key, value in output.items():
+            if key == 'json':
+                for item in value:
+                    categories.append(item.get('elements', 'N/A').replace('_', ' ').title())
+                    current_footprint.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:** {current_footprint[i]}\n\n"
+        
+        return output
+    
+    def initialize_analyze_session(self):
+        if 'analyzing' not in st.session_state:
+            st.session_state['analyzing'] = False
+        return st.session_state.get('analyzing', False)
+    
+    def hide_button(self):
+        if st.session_state['analyzing'] == True:
+            st.markdown(
+                """
+                    <style>
+                    .element-container:nth-of-type(5) button {
+                    display: none;
+                    }
+                    </style>
+                """,
+                unsafe_allow_html=True,
+            )
+        elif st.session_state['analyzing'] == False:
+            st.markdown(
+            """
+                <style>
+                element-container:nth-of-type(5) button {
+                display: inline;
+                }
+                </style>
+            """,
+            unsafe_allow_html=True,
+        )
+    
+    def detect_encoding(self, uploaded_file):
+        result = chardet.detect(uploaded_file.read(100000))
+        uploaded_file.seek(0)  # Reset file pointer to the beginning
+        return result['encoding']
+
+   
+    def row1(self):
+        col1, col2 = st.columns(2, gap="medium")
+        with col1:
+            st.write("") # FOR SPACING
+            st.write(self.data_src)
+            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
+            if self.uploaded_files:
+                upload.multiple_upload_file(self.uploaded_files)
+                self.file_dict = upload.file_dict
+                
+        with col2:
+            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=self.initialize_analyze_session())
+            if analyze_button:
+                st.session_state['analyzing'] = True 
+                self.hide_button()
+                start_time = time.time()
+                if self.uploaded_files:
+                    combined_text = ""
+                    with st.spinner('Analyzing...', show_time=True):
+                        st.write('')
+                        for file_info in st.session_state['uploaded_files'].values():
+                            if file_info['type'] == 'pdf':
+                                combined_text += file_info['content'] + "\n"
+                            elif file_info['type'] == 'csv':
+                                combined_text += file_info['content'].to_csv(index=True) + "\n"
+                        
+                        # 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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files']],'payload': payload_txt, 'result': result}
+                        
+                        collect_telemetry(debug_info)
+                        
+                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
+                            st.write(debug_info.pop("result"))
+                            
+                        with st.expander("Debug information", icon="⚙"):
+                            st.write(debug_info)
+
+
+                        st.session_state['analyzing'] = False
+
+                        for df_seo in st.session_state.keys():
+                            del st.session_state[df_seo]
+                        self.file_dict.popitem()
+
+                else:
+                    st.info("Please upload CSV or PDF files first.")
+                    st.session_state['analyzing'] = False
+                    self.hide_button()       
+
+if __name__ == "__main__":
+    st.set_page_config(layout="wide")
+
+upload = uploadFile()

helper/upload_File.py

@@ -0,0 +1,32 @@
+from gradio import JSON
+import streamlit as st
+import pandas as pd
+import pymupdf
+
+
+class uploadFile:
+    def __init__(self):
+        self.file_dict = {}
+
+    def multiple_upload_file(self, uploaded_files):
+        for _ in range(len(self.file_dict)):
+            self.file_dict.popitem() 
+
+        for uploaded_file in uploaded_files:
+            if uploaded_file.type == "application/pdf":
+                with pymupdf.open(stream=uploaded_file.read(), filetype="pdf") as doc:  
+                    text = chr(12).join([page.get_text() for page in doc])
+                    self.file_dict[uploaded_file.name] = {'type': 'pdf', 'content': text}
+            elif uploaded_file.type == "text/csv":
+                try:
+                    df = pd.read_csv(uploaded_file)
+                    self.file_dict[uploaded_file.name] = {'type': 'csv', 'content': df}
+                except Exception as e:
+                    pass
+   
+            st.session_state['uploaded_files'] = self.file_dict
+
+if __name__ == "__main__":
+    app = uploadFile()
+    st.set_page_config(layout="wide")
+

helper/upload_traffic.py

@@ -0,0 +1,33 @@
+from gradio import JSON
+import streamlit as st
+import pandas as pd
+import pymupdf
+
+
+
+class upload_traffic:
+    def __init__(self):
+        self.file_dict = {}
+
+    def multiple_upload_file(self, uploaded_files):
+        for _ in range(len(self.file_dict)):
+            self.file_dict.popitem() 
+
+        for uploaded_file in uploaded_files:
+            if uploaded_file.type == "application/pdf":
+                with pymupdf.open(stream=uploaded_file.read(), filetype="pdf") as doc:  
+                    text = chr(12).join([page.get_text() for page in doc])
+                    self.file_dict[uploaded_file.name] = {'type': 'pdf', 'content': text}
+            elif uploaded_file.type == "text/csv":
+                try:
+                    df = pd.read_csv(uploaded_file)
+                    self.file_dict[uploaded_file.name] = {'type': 'csv', 'content': df}
+                except Exception as e:
+                    pass
+   
+            st.session_state['uploaded_files'] = self.file_dict
+
+if __name__ == "__main__":
+    app = upload_traffic()
+    st.set_page_config(layout="wide")
+

pages/EDA.py

@@ -1,85 +0,0 @@
-import streamlit as st
-from st_img_pastebutton import paste
-from streamlit_paste_button import paste_image_button as pbutton
-import requests
-from dotenv import load_dotenv
-import os
-import chardet
-import pandas as pd
-
-class EDAApp:
-    def __init__(self):
-        self.uploaded_file = None
-        self.img_b64 = None
-        self.initialize()
-        
-    def initialize(self):
-        # FOR ENV
-        load_dotenv()
-
-        # FOR PAGE LAYOUT
-        st.set_page_config(layout="wide")
-
-        st.header('EDA')
-        if st.button("Return", key=1):
-            st.switch_page("./app.py")
-
-    def request_model(self, payload_txt):
-        response = requests.post(os.getenv('MODEL_Image_Describer'), json=payload_txt)
-        response.raise_for_status()
-        output = response.json()
-        result = f"{output['text']}"
-        return result
-    
-    def detect_encoding(self, uploaded_file):
-        result = chardet.detect(uploaded_file.read(100000))
-        uploaded_file.seek(0)  # Reset file pointer to the beginning
-        return result['encoding']
-    
-    def summarize_data(self, df):
-        info = df.info()
-        st.session_state['info'] = info
-
-        summary_stats = df.describe(include='all')
-        st.session_state['summary_stats'] = summary_stats
-
-    def print_data_distribution(self, df):
-        distributions = {}
-        for column in df.select_dtypes(include=['number']).columns:
-            distribution = df[column].describe()
-            distributions[column] = distribution
-        st.session_state['distribution'] = distributions
-
-    def row1(self):
-        col1, col2 = st.columns(2, gap="medium")
-        with col1:
-            self.uploaded_file = st.file_uploader("Upload CSV", type='csv')
-            if self.uploaded_file is not None:
-                encoding = self.detect_encoding(self.uploaded_file)
-                df = pd.read_csv(self.uploaded_file, encoding=encoding, low_memory=False)
-                st.session_state['df'] = df
-
-        with col2:
-            st.write("AI Analyst Output: ")
-            if st.button("Analyze", key=2):
-                if 'df' in st.session_state:
-                    df = st.session_state['df']
-                    self.summarize_data(df)
-                    self.print_data_distribution(df)
-
-                    info = st.session_state['info']
-                    summary_stats = st.session_state['summary_stats']
-                    distribution = st.session_state['distribution']
-
-                    payload_txt = {
-                        "question": f"{info}, {summary_stats}, {distribution}",
-                        "chatId": "some-session-id",
-                    }
-                    result = self.request_model(payload_txt)
-                    st.write(result)
-                else:
-                    st.write("Please upload a CSV file first.")
-
-if __name__ == "__main__":
-    app = EDAApp()
-    app.row1()

pages/Traffic_EDA.py

@@ -1,105 +0,0 @@
-import streamlit as st
-from st_img_pastebutton import paste
-from streamlit_paste_button import paste_image_button as pbutton
-import requests
-from dotenv import load_dotenv
-import os
-import chardet
-import pandas as pd
-
-class EDAApp:
-    def __init__(self):
-        self.uploaded_file = None
-        self.img_b64 = None
-        self.initialize()
-        
-    def initialize(self):
-        # FOR PAGE LAYOUT
-        st.set_page_config(layout="wide")
-
-        st.header('EDA')
-        if st.button("Return", key=1):
-            st.switch_page("./app.py")
-
-    def detect_encoding(self, uploaded_file):
-        result = chardet.detect(uploaded_file.read(100000))
-        uploaded_file.seek(0)  # Reset file pointer to the beginning
-        return result['encoding']
-    
-    def keyword_ranking(self, df_seo):
-        keyword_ranking = df_seo
-        st.session_state['keyword_ranking'] = keyword_ranking
-
-        keywords_ranking_sorted = keyword_ranking.sort_values("Position", ascending=True)
-
-        keywords_ranking_top_10 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 10].shape[0]
-        keywords_ranking_top_100 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 100].shape[0]
-
-        keyword_ranking = {
-            'Keyword_top_10': keywords_ranking_top_10,
-            'Keyword_top_100': keywords_ranking_top_100
-        }
-        st.session_state['keyword_ranking'] = keyword_ranking
-
-    def traffic_files(self, df):
-        traffic_channels = df
-        traffic_channels.rename(columns={traffic_channels.columns[0]: 'date'}, inplace=True)
-        traffic_channels['date'] = pd.to_datetime(traffic_channels['date'], format='mixed')
-
-        traffic_channels_sort = traffic_channels.sort_values("date", ascending=False)
-
-        organic_traffic = traffic_channels_sort['Organic Search'].values[0]
-        paid_traffic = traffic_channels_sort['Paid Search'].values[0]
-        direct_traffic = traffic_channels_sort['Direct'].values[0]
-        referral_traffic = traffic_channels_sort['Referral'].values[0]
-
-        st.session_state['organic_traffic'] = organic_traffic
-        st.session_state['paid_traffic'] = paid_traffic
-        st.session_state['direct_traffic'] = direct_traffic
-        st.session_state['referral_traffic'] = referral_traffic
-        
-    def row1(self):
-        col1, col2 = st.columns(2, gap="medium")
-        with col1:
-            self.uploaded_file = st.file_uploader("Upload Traffic Files CSV", type='csv')
-            if self.uploaded_file is not None:
-                encoding = self.detect_encoding(self.uploaded_file)
-                df = pd.read_csv(self.uploaded_file, encoding=encoding, low_memory=False)
-                st.session_state['df'] = df
-
-            self.uploaded_file_seo = st.file_uploader("Upload SEO Keywords CSV", type='csv', key=3)
-            if self.uploaded_file_seo is not None:
-                encoding_seo = self.detect_encoding(self.uploaded_file_seo)
-                df_seo = pd.read_csv(self.uploaded_file_seo, encoding=encoding_seo, low_memory=False)
-                st.session_state['df_seo'] = df_seo
-
-        with col2:
-            st.write("AI Analyst Output: ")
-            if st.button("Analyze", key=2):
-                if 'df' in st.session_state or 'df_seo' in st.session_state:
-                    df = st.session_state['df']
-                    df_seo = st.session_state['df_seo']
-                    self.keyword_ranking(df_seo)
-                    self.traffic_files(df)
-        
-                    keyword_ranking = st.session_state['keyword_ranking']    
-                    organic_traffic = st.session_state['organic_traffic']
-                    paid_traffic = st.session_state['paid_traffic']
-                    direct_traffic = st.session_state['direct_traffic']
-                    referral_traffic = st.session_state['referral_traffic']
-
-                    output_10 = keyword_ranking['Keyword_top_10']
-                    output_100 = keyword_ranking['Keyword_top_100']
-
-                    st.write("Total Keywords Ranking Top 10: ", output_10)
-                    st.write("Total Keywords Ranking Top 100: ", output_100)
-                    st.write("Organic Traffic: ", organic_traffic)
-                    st.write("Paid Traffic: ", paid_traffic)
-                    st.write("Direct Traffic: ", direct_traffic)
-                    st.write("Referral Traffic: ", referral_traffic)
-                else:
-                    st.write("Please upload a CSV file first.")
-
-if __name__ == "__main__":
-    app = EDAApp()
-    app.row1()

pages/agent_1.py

@@ -1,7 +1,6 @@
 import os
-from parent import SeoOffPageAnalyst
 from app import Analysts, Analysts_Description, Data_Source
-import streamlit as st
+from classes.Seo_Off_Page import SeoOffPageAnalyst
 
 # SPECIFY API URL & ANALYST NAME
 start = SeoOffPageAnalyst(os.getenv('MODEL_Off_Page_Analyst'), Analysts['Analyst 1'], Data_Source['Analyst_Src 1'],Analysts_Description['Analyst_Desc 1'])

pages/agent_2.py

@@ -1,7 +1,6 @@
 import os
-from parent import SeoOnPageAnalyst
 from app import Analysts, Analysts_Description, Data_Source
-import streamlit as st
+from classes.Seo_On_Page import SeoOnPageAnalyst
 
 # SPECIFY API URL ANALYST NAME, DATA SOURCE & DESCRIPTION
 start = SeoOnPageAnalyst(os.getenv('MODEL_On_Page_Analyst'), Analysts['Analyst 2'], Data_Source['Analyst_Src 2'],Analysts_Description['Analyst_Desc 2'])

pages/agent_3.py

@@ -1,7 +1,7 @@
 import os
-from parent import SeoAnalyst
 from app import Analysts, Analysts_Description, Data_Source
 import streamlit as st
+from classes.Seo import SeoAnalyst
 
 # SPECIFY API URL & ANALYST NAME
 start = SeoAnalyst(os.getenv('MODEL_SEO_Analyst'), Analysts['Analyst 3'], Data_Source['Analyst_Src 3'],Analysts_Description['Analyst_Desc 3'])

parent.py

@@ -145,513 +145,6 @@ if __name__ == "__main__":
     app = uploadFile()
     st.set_page_config(layout="wide")
 
-class SeoAnalyst:
-    def __init__(self, model_url, analyst_name, data_src, analyst_description):
-        self.uploaded_files = []
-        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.initialize_analyze_session()
-        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("./app.py")
-        except Exception:
-            pass
-    
-    def request_model(self, payload_txt):
-        response = requests.post(self.model_url, json=payload_txt)
-        response.raise_for_status()
-        output = response.json()
-        output_dict = {key: value for key, value in output.items()}
-        output_str = json.dumps(output_dict, indent=8, sort_keys=False)
-        
-        categories = []
-        current_footprint = []
-        number_of_backlinks = []
-
-        for key, value in output.items():
-            if key == 'json':
-                for item in value:
-                    categories.append(item.get('category', 'N/A').replace('_', ' ').title())
-                    current_footprint.append(item.get('current_footprint', 'N/A'))
-                    number_of_backlinks.append(item.get('best_of_breed_solution', 'N/A'))    
-
-        output = ""
-        for i in range(len(categories)):
-            output += f"\n\n---\n **Category:** {categories[i]}"
-            output += f"\n\n **Current Footprint:** {current_footprint[i]}\n\n"
-            output += f"**Number of Backlinks:** {number_of_backlinks[i]}"
-        
-        return output
-    
-    def initialize_analyze_session(self):
-        if 'analyzing' not in st.session_state:
-            st.session_state['analyzing'] = False
-        return st.session_state.get('analyzing', False)
-    
-    def hide_button(self):
-        if st.session_state['analyzing'] == True:
-            st.markdown(
-                """
-                    <style>
-                    .element-container:nth-of-type(5) button {
-                    display: none;
-                    }
-                    </style>
-                """,
-                unsafe_allow_html=True,
-            )
-        elif st.session_state['analyzing'] == False:
-            st.markdown(
-            """
-                <style>
-                element-container:nth-of-type(5) button {
-                display: inline;
-                }
-                </style>
-            """,
-            unsafe_allow_html=True,
-        )
-    
-    def detect_encoding(self, uploaded_file):
-        result = chardet.detect(uploaded_file.read(100000))
-        uploaded_file.seek(0)  # Reset file pointer to the beginning
-        return result['encoding']
-
-    def keyword_ranking(self, df_seo):
-        keyword_ranking = df_seo
-        st.session_state['keyword_ranking'] = keyword_ranking
-
-        keywords_ranking_sorted = keyword_ranking.sort_values("Position", ascending=True)
-
-        keywords_ranking_top_10 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 10].shape[0]
-        keywords_ranking_top_100 = keywords_ranking_sorted[keywords_ranking_sorted["Position"] <= 100].shape[0]
-
-        keyword_ranking = {
-            'Keyword_top_10': keywords_ranking_top_10,
-            'Keyword_top_100': keywords_ranking_top_100
-        }
-        st.session_state['keyword_ranking'] = keyword_ranking
-
-    def traffic_files(self, df):
-        traffic_channels = df
-        traffic_channels.rename(columns={traffic_channels.columns[0]: 'date'}, inplace=True)
-        traffic_channels['date'] = pd.to_datetime(traffic_channels['date'], format='mixed')
-
-        traffic_channels_sort = traffic_channels.sort_values("date", ascending=False)
-
-        organic_traffic = traffic_channels_sort['Organic Search'].values[0]
-        paid_traffic = traffic_channels_sort['Paid Search'].values[0]
-        direct_traffic = traffic_channels_sort['Direct'].values[0]
-        referral_traffic = traffic_channels_sort['Referral'].values[0]
-
-        st.session_state['organic_traffic'] = organic_traffic
-        st.session_state['paid_traffic'] = paid_traffic
-        st.session_state['direct_traffic'] = direct_traffic
-        st.session_state['referral_traffic'] = referral_traffic
-   
-    def row1(self):
-        col1, col2 = st.columns(2, gap="medium")
-        with col1:
-            st.write("") # FOR SPACING
-            st.write(self.data_src)
-            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
-            if self.uploaded_files:
-                upload.multiple_upload_file(self.uploaded_files)
-                self.file_dict = upload.file_dict
-
-            self.uploaded_file = st.file_uploader("Upload Traffic Files CSV", type='csv')
-            if self.uploaded_file is not None:
-                encoding = self.detect_encoding(self.uploaded_file)
-                st.session_state['df'] = pd.read_csv(self.uploaded_file, encoding=encoding, low_memory=False)
-                
-
-            st.write("") # FOR THE HIDE BUTTON
-            self.uploaded_file_seo = st.file_uploader("Upload SEO Keywords CSV", type='csv', key=3)
-            if self.uploaded_file_seo is not None:
-                encoding_seo = self.detect_encoding(self.uploaded_file_seo)
-                st.session_state['df_seo'] = pd.read_csv(self.uploaded_file_seo, encoding=encoding_seo, low_memory=False)
-                
-        with col2:
-            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=self.initialize_analyze_session())
-            start_time = time.time()
-            if analyze_button:
-                st.session_state['analyzing'] = True 
-                self.hide_button()
-                if self.uploaded_files:
-                    combined_text = ""
-                    with st.spinner('Analyzing...', show_time=True):
-                        st.write('')
-                        for file_info in st.session_state['uploaded_files'].values():
-                            if file_info['type'] == 'pdf':
-                                combined_text += file_info['content'] + "\n"
-                            elif file_info['type'] == 'csv':
-                                combined_text += file_info['content'].to_csv(index=True) + "\n"
-                        # INITIALIZING SESSIONS
-                        try:
-                            df = st.session_state['df']
-                            df_seo = st.session_state['df_seo']
-                            self.keyword_ranking(df_seo)
-                            self.traffic_files(df)
-                            keyword_ranking = st.session_state['keyword_ranking']    
-                            organic_traffic = st.session_state['organic_traffic']
-                            paid_traffic = st.session_state['paid_traffic']
-                            direct_traffic = st.session_state['direct_traffic']
-                            referral_traffic = st.session_state['referral_traffic']
-
-                            combined_text += df.to_csv(index=True)
-                            combined_text += f"\nKeyword Ranking Top 10: {keyword_ranking['Keyword_top_10']}"
-                            combined_text += f"\nKeyword Ranking Top 100: {keyword_ranking['Keyword_top_100']}\n\n"
-                            
-                            
-                            combined_text += df_seo.to_csv(index=True)
-                            combined_text += f"\nOrganic Traffic: {organic_traffic}"
-                            combined_text += f"\nPaid Traffic: {paid_traffic}"
-                            combined_text += f"\nDirect Traffic: {direct_traffic}"
-                            combined_text += f"\nReferral Traffic: {referral_traffic}"
-                        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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files'],],'payload': payload_txt, 'result': result}
-                        
-                        collect_telemetry(debug_info)
-                        
-                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
-                            st.write(debug_info.pop("result"))
-                            
-                        with st.expander("Debug information", icon="⚙"):
-                            st.write(debug_info)
-
-                        st.session_state['analyzing'] = False
-
-                else:
-                    st.info("Please upload CSV or PDF files first.")
-                    st.session_state['analyzing'] = False
-                    self.hide_button()       
-
-if __name__ == "__main__":
-    st.set_page_config(layout="wide")
-
-class SeoOnPageAnalyst:
-    def __init__(self, model_url, analyst_name, data_src, analyst_description):
-        self.uploaded_files = []
-        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.initialize_analyze_session()
-        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("./app.py")
-        except Exception:
-            pass
-    
-    def request_model(self, payload_txt):
-        response = requests.post(self.model_url, json=payload_txt)
-        response.raise_for_status()
-        output = response.json()
-        
-        categories = []
-        current_footprint = []
-        number_of_backlinks = []
-
-        for key, value in output.items():
-            if key == 'json':
-                for item in value:
-                    categories.append(item.get('elements', 'N/A').replace('_', ' ').title())
-                    current_footprint.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:** {current_footprint[i]}\n\n"
-        
-        return output
-    
-    def initialize_analyze_session(self):
-        if 'analyzing' not in st.session_state:
-            st.session_state['analyzing'] = False
-        return st.session_state.get('analyzing', False)
-    
-    def hide_button(self):
-        if st.session_state['analyzing'] == True:
-            st.markdown(
-                """
-                    <style>
-                    .element-container:nth-of-type(5) button {
-                    display: none;
-                    }
-                    </style>
-                """,
-                unsafe_allow_html=True,
-            )
-        elif st.session_state['analyzing'] == False:
-            st.markdown(
-            """
-                <style>
-                element-container:nth-of-type(5) button {
-                display: inline;
-                }
-                </style>
-            """,
-            unsafe_allow_html=True,
-        )
-    
-    def detect_encoding(self, uploaded_file):
-        result = chardet.detect(uploaded_file.read(100000))
-        uploaded_file.seek(0)  # Reset file pointer to the beginning
-        return result['encoding']
-
-   
-    def row1(self):
-        col1, col2 = st.columns(2, gap="medium")
-        with col1:
-            st.write("") # FOR SPACING
-            st.write(self.data_src)
-            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
-            if self.uploaded_files:
-                upload.multiple_upload_file(self.uploaded_files)
-                self.file_dict = upload.file_dict
-                
-        with col2:
-            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=self.initialize_analyze_session())
-            if analyze_button:
-                st.session_state['analyzing'] = True 
-                self.hide_button()
-                start_time = time.time()
-                if self.uploaded_files:
-                    combined_text = ""
-                    with st.spinner('Analyzing...', show_time=True):
-                        st.write('')
-                        for file_info in st.session_state['uploaded_files'].values():
-                            if file_info['type'] == 'pdf':
-                                combined_text += file_info['content'] + "\n"
-                            elif file_info['type'] == 'csv':
-                                combined_text += file_info['content'].to_csv(index=True) + "\n"
-                        
-                        # 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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files']],'payload': payload_txt, 'result': result}
-                        
-                        collect_telemetry(debug_info)
-                        
-                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
-                            st.write(debug_info.pop("result"))
-                            
-                        with st.expander("Debug information", icon="⚙"):
-                            st.write(debug_info)
-
-
-                        st.session_state['analyzing'] = False
-
-                else:
-                    st.info("Please upload CSV or PDF files first.")
-                    st.session_state['analyzing'] = False
-                    self.hide_button()       
-
-if __name__ == "__main__":
-    st.set_page_config(layout="wide")
-
-class SeoOffPageAnalyst:
-    def __init__(self, model_url, analyst_name, data_src, analyst_description):
-        self.uploaded_files = []
-        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.initialize_analyze_session()
-        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("./app.py")
-        except Exception:
-            pass
-    
-    def request_model(self, payload_txt):
-        response = requests.post(self.model_url, json=payload_txt)
-        response.raise_for_status()
-        output = response.json()
-        
-        categories = []
-        current_footprint = []
-        number_of_backlinks = []
-
-        for key, value in output.items():
-            if key == 'json':
-                for item in value:
-                    categories.append(item.get('elements', 'N/A').replace('_', ' ').title())
-                    current_footprint.append(item.get('remarks', 'N/A'))
-                    number_of_backlinks.append(item.get('count', 'N/A'))
-
-        output = ""
-        for i in range(len(categories)):
-            output += f"\n\n---\n **Category:** {categories[i]}"
-            output += f"\n\n **Remarks:** {current_footprint[i]}\n\n"
-            output += f"**Count:** {number_of_backlinks[i]}"
-        
-        return output
-    
-    def initialize_analyze_session(self):
-        if 'analyzing' not in st.session_state:
-            st.session_state['analyzing'] = False
-        return st.session_state.get('analyzing', False)
-    
-    def hide_button(self):
-        if st.session_state['analyzing'] == True:
-            st.markdown(
-                """
-                    <style>
-                    .element-container:nth-of-type(5) button {
-                    display: none;
-                    }
-                    </style>
-                """,
-                unsafe_allow_html=True,
-            )
-        elif st.session_state['analyzing'] == False:
-            st.markdown(
-            """
-                <style>
-                element-container:nth-of-type(5) button {
-                display: inline;
-                }
-                </style>
-            """,
-            unsafe_allow_html=True,
-        )
-    
-    def detect_encoding(self, uploaded_file):
-        result = chardet.detect(uploaded_file.read(100000))
-        uploaded_file.seek(0)  # Reset file pointer to the beginning
-        return result['encoding']
-
-   
-    def row1(self):
-        col1, col2 = st.columns(2, gap="medium")
-        with col1:
-            st.write("") # FOR SPACING
-            st.write(self.data_src)
-            self.uploaded_files = st.file_uploader(self.analyst_description, type=['pdf', 'csv'], accept_multiple_files=True)
-            if self.uploaded_files:
-                upload.multiple_upload_file(self.uploaded_files)
-                self.file_dict = upload.file_dict
-                
-        with col2:
-            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=self.initialize_analyze_session())
-            start_time = time.time()
-            if analyze_button:
-                st.session_state['analyzing'] = True 
-                self.hide_button()
-                if self.uploaded_files:
-                    combined_text = ""
-                    with st.spinner('Analyzing...', show_time=True):
-                        st.write('')
-                        for file_info in st.session_state['uploaded_files'].values():
-                            if file_info['type'] == 'pdf':
-                                combined_text += file_info['content'] + "\n"
-                            elif file_info['type'] == 'csv':
-                                combined_text += file_info['content'].to_csv(index=True) + "\n"
-                        
-                        # 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 = {'analyst': self.analyst_name,'url_uuid': self.model_url.split("-")[-1],'time_lapsed' : time_lapsed, 'files': [*st.session_state['uploaded_files']],'payload': payload_txt, 'result': result}
-                        
-                        collect_telemetry(debug_info)
-                        
-                        with st.expander("AI Analysis", expanded=True, icon="🤖"):
-                            st.write(debug_info.pop("result"))
-                            
-                        with st.expander("Debug information", icon="⚙"):
-                            st.write(debug_info)
-
-                        st.session_state['analyzing'] = False
-
-                else:
-                    st.info("Please upload CSV or PDF files first.")
-                    st.session_state['analyzing'] = False
-                    self.hide_button()       
-
-if __name__ == "__main__":
-    st.set_page_config(layout="wide")
-
 # # INITIALIZATION
 # model_url = os.getenv('MODEL_On_Page_Analyst')
 # analyst_name = Analysts['Analyst 1']