Update app.py

app.py

@@ -223,175 +223,178 @@ else:
         st.session_state['uploaded_file_content'] = None
         st.session_state['file_uploader_key'] += 1
 
-# --- Main Processing Logic (triggered by input or refresh) ---
-experiment = None
-start_time_overall = None
+# --- Main Processing Logic (corrected placement) ---
+# The button must be outside the conditional logic that populates the session state
+# so that it is always rendered and can be clicked to trigger the analysis.
+if st.button("Analyze Text", type="primary"):
+    if st.session_state['encrypted_text_to_process']:
+        try:
+            start_time_overall = time.time()
+
+            if st.session_state['source_type_attempts'] >= max_attempts:
+                st.error(f"You have requested results {max_attempts} times. You have reached your request limit.")
+                st.stop()
+            
+            st.session_state['source_type_attempts'] += 1
+            save_persistent_data(st.session_state['source_type_attempts'], st.session_state['file_upload_history'])
+
+            @st.cache_resource
+            def load_ner_model():
+                return pipeline("token-classification",
+                                model="ml6team/keyphrase-extraction-kbir-inspec",
+                                aggregation_strategy="max",
+                                stride=128,
+                                ignore_labels=["O"])
+
+            model = load_ner_model()
+            text_for_ner = decrypt_text(st.session_state['encrypted_text_to_process'])
+
+            if text_for_ner and len(text_for_ner.strip()) > 0:
+                with st.spinner("Analyzing text...", show_time=True):
+                    entities = model(text_for_ner)
+                    data = []
+                    if entities:
+                        for entity in entities:
+                            if all(k in entity for k in ['word', 'entity_group', 'score', 'start', 'end']):
+                                data.append({
+                                    'word': entity['word'],
+                                    'entity_group': entity['entity_group'],
+                                    'score': entity['score'],
+                                    'start': entity['start'],
+                                    'end': entity['end']
+                                })
+                            else:
+                                st.warning(f"Skipping malformed entity encountered: {entity}. Missing expected keys.")
+                        df = pd.DataFrame(data)
+                    else:
+                        df = pd.DataFrame(columns=['word', 'entity_group', 'score', 'start', 'end'])
 
-if st.button("Analyze Text", type="primary") and st.session_state['encrypted_text_to_process']:
-    try:
-        start_time_overall = time.time()
+                    if not df.empty:
+                        pattern = r'[^\w\s]'
+                        df['word'] = df['word'].replace(pattern, '', regex=True)
+                        df = df.replace('', 'Unknown')
 
-        if st.session_state['source_type_attempts'] >= max_attempts:
-            st.error(f"You have requested results {max_attempts} times. You have reached your request limit.")
-            st.stop()
-        
-        st.session_state['source_type_attempts'] += 1
-        save_persistent_data(st.session_state['source_type_attempts'], st.session_state['file_upload_history'])
+                        st.subheader("All Extracted Keyphrases", divider="rainbow")
+                        st.dataframe(df, use_container_width=True)
 
-        @st.cache_resource
-        def load_ner_model():
-            return pipeline("token-classification",
-                            model="ml6team/keyphrase-extraction-kbir-inspec",
-                            aggregation_strategy="max",
-                            stride=128,
-                            ignore_labels=["O"])
-
-        model = load_ner_model()
-        text_for_ner = decrypt_text(st.session_state['encrypted_text_to_process'])
-
-        if text_for_ner and len(text_for_ner.strip()) > 0:
-            with st.spinner("Analyzing text...", show_time=True):
-                entities = model(text_for_ner)
-                data = []
-                if entities:
-                    for entity in entities:
-                        if all(k in entity for k in ['word', 'entity_group', 'score', 'start', 'end']):
-                            data.append({
-                                'word': entity['word'],
-                                'entity_group': entity['entity_group'],
-                                'score': entity['score'],
-                                'start': entity['start'],
-                                'end': entity['end']
-                            })
-                        else:
-                            st.warning(f"Skipping malformed entity encountered: {entity}. Missing expected keys.")
-                    df = pd.DataFrame(data)
-                else:
-                    df = pd.DataFrame(columns=['word', 'entity_group', 'score', 'start', 'end'])
-
-                if not df.empty:
-                    pattern = r'[^\w\s]'
-                    df['word'] = df['word'].replace(pattern, '', regex=True)
-                    df = df.replace('', 'Unknown')
-
-                    st.subheader("All Extracted Keyphrases", divider="rainbow")
-                    st.dataframe(df, use_container_width=True)
-
-                    with st.expander("See Glossary of tags"):
-                        st.write('''
-                        **word**: ['entity extracted from your text data']
-                        
-                        **score**: ['accuracy score; how accurately a tag has been assigned to a given entity']
-                        
-                        **entity_group**: ['label (tag) assigned to a given extracted entity']
-                        
-                        **start**: ['index of the start of the corresponding entity']
-                        
-                        **end**: ['index of the end of the corresponding entity']
-                        
-                        ''')
-                    st.divider()
+                        with st.expander("See Glossary of tags"):
+                            st.write('''
+                            **word**: ['entity extracted from your text data']
+                            
+                            **score**: ['accuracy score; how accurately a tag has been assigned to a given entity']
+                            
+                            **entity_group**: ['label (tag) assigned to a given extracted entity']
+                            
+                            **start**: ['index of the start of the corresponding entity']
+                            
+                            **end**: ['index of the end of the corresponding entity']
+                            
+                            ''')
+                        st.divider()
 
-                    st.subheader("Most Frequent Keyphrases", divider="rainbow")
-                    word_counts = df['word'].value_counts().reset_index()
-                    word_counts.columns = ['word', 'count']
-                    df_frequent = word_counts.sort_values(by='count', ascending=False).head(15)
+                        st.subheader("Most Frequent Keyphrases", divider="rainbow")
+                        word_counts = df['word'].value_counts().reset_index()
+                        word_counts.columns = ['word', 'count']
+                        df_frequent = word_counts.sort_values(by='count', ascending=False).head(15)
 
-                    if not df_frequent.empty:
-                        tab1, tab2 = st.tabs(["Table", "Chart"])
+                        if not df_frequent.empty:
+                            tab1, tab2 = st.tabs(["Table", "Chart"])
 
-                        with tab1:
-                            st.dataframe(df_frequent, use_container_width=True)
+                            with tab1:
+                                st.dataframe(df_frequent, use_container_width=True)
+                            
+                            with tab2:
+                                fig_frequent_bar = px.bar(
+                                    df_frequent,
+                                    x='count',
+                                    y='word',
+                                    orientation='h',
+                                    title='Top Frequent Keyphrases by Count',
+                                    color='count',
+                                    color_continuous_scale=px.colors.sequential.Viridis
+                                )
+                                fig_frequent_bar.update_layout(yaxis={'categoryorder':'total ascending'})
+                                st.plotly_chart(fig_frequent_bar, use_container_width=True)
+                                
+                                if comet_initialized and 'experiment' in locals():
+                                    experiment.log_figure(figure=fig_frequent_bar, figure_name="frequent_keyphrases_bar_chart")
+                        else:
+                            st.info("No keyphrases found with more than one occurrence to display in tabs.")
                         
-                        with tab2:
-                            fig_frequent_bar = px.bar(
-                                df_frequent,
-                                x='count',
-                                y='word',
-                                orientation='h',
-                                title='Top Frequent Keyphrases by Count',
-                                color='count',
-                                color_continuous_scale=px.colors.sequential.Viridis
+                        st.divider()
+
+                        experiment = None
+                        if comet_initialized:
+                            experiment = Experiment(
+                                api_key=COMET_API_KEY,
+                                workspace=COMET_WORKSPACE,
+                                project_name=COMET_PROJECT_NAME,
                             )
-                            fig_frequent_bar.update_layout(yaxis={'categoryorder':'total ascending'})
-                            st.plotly_chart(fig_frequent_bar, use_container_width=True)
-                            
-                            if comet_initialized and experiment:
-                                experiment.log_figure(figure=fig_frequent_bar, figure_name="frequent_keyphrases_bar_chart")
-                    else:
-                        st.info("No keyphrases found with more than one occurrence to display in tabs.")
-                    
-                    st.divider()
-
-                    if comet_initialized:
-                        experiment = Experiment(
-                            api_key=COMET_API_KEY,
-                            workspace=COMET_WORKSPACE,
-                            project_name=COMET_PROJECT_NAME,
+                            experiment.log_parameter("input_source_type", source_type)
+                            experiment.log_parameter("input_content_length", len(text_for_ner))
+                            experiment.log_table("predicted_entities", df)
+
+                        st.subheader("Treemap of All Keyphrases", divider="rainbow")
+                        fig_treemap = px.treemap(
+                            df,
+                            path=[px.Constant("all"), 'entity_group', 'word'],
+                            values='score',
+                            color='word',
+                            color_continuous_scale=px.colors.sequential.Plasma
                         )
-                        experiment.log_parameter("input_source_type", source_type)
-                        experiment.log_parameter("input_content_length", len(text_for_ner))
-                        experiment.log_table("predicted_entities", df)
-
-                    st.subheader("Treemap of All Keyphrases", divider="rainbow")
-                    fig_treemap = px.treemap(
-                        df,
-                        path=[px.Constant("all"), 'entity_group', 'word'],
-                        values='score',
-                        color='word',
-                        color_continuous_scale=px.colors.sequential.Plasma
-                    )
-                    fig_treemap.update_layout(margin=dict(t=50, l=25, r=25, b=25))
-                    st.plotly_chart(fig_treemap, use_container_width=True)
-
-                    if comet_initialized and experiment:
-                        experiment.log_figure(figure=fig_treemap, figure_name="entity_treemap")
-
-                    # --- Download Section ---
-                    dfa = pd.DataFrame(
-                        data={
-                            'Column Name': ['word', 'entity_group', 'score', 'start', 'end'],
-                            'Description': [
-                                'entity extracted from your text data',
-                                'label (tag) assigned to a given extracted entity',
-                                'accuracy score; how accurately a tag has been assigned to a given entity',
-                                'index of the start of the corresponding entity',
-                                'index of the end of the corresponding entity'
-                            ]
-                        }
-                    )
-                    buf = io.BytesIO()
-                    with zipfile.ZipFile(buf, "w") as myzip:
-                        if not df.empty:
-                            myzip.writestr("Summary_of_results.csv", df.to_csv(index=False))
-                            myzip.writestr("Most_frequent_keyphrases.csv", df_frequent.to_csv(index=False))
-                        myzip.writestr("Glossary_of_tags.csv", dfa.to_csv(index=False))
-
-                    with stylable_container(
-                        key="download_button",
-                        css_styles="""button { background-color: yellow; border: 1px solid black; padding: 5px; color: black; }""",
-                    ):
-                        st.download_button(
-                            label="Download zip file",
-                            data=buf.getvalue(),
-                            file_name="nlpblogs_ner_results.zip",
-                            mime="application/zip",
+                        fig_treemap.update_layout(margin=dict(t=50, l=25, r=25, b=25))
+                        st.plotly_chart(fig_treemap, use_container_width=True)
+
+                        if comet_initialized and experiment:
+                            experiment.log_figure(figure=fig_treemap, figure_name="entity_treemap")
+
+                        # --- Download Section ---
+                        dfa = pd.DataFrame(
+                            data={
+                                'Column Name': ['word', 'entity_group', 'score', 'start', 'end'],
+                                'Description': [
+                                    'entity extracted from your text data',
+                                    'label (tag) assigned to a given extracted entity',
+                                    'accuracy score; how accurately a tag has been assigned to a given entity',
+                                    'index of the start of the corresponding entity',
+                                    'index of the end of the corresponding entity'
+                                ]
+                            }
                         )
-                    st.divider()
-                else:
-                    st.warning("No entities found to generate visualizations.")
-        else:
-            st.warning("No meaningful text found to process. Please enter a URL, upload a text file, or type/paste text.")
-    except Exception as e:
-        st.error(f"An unexpected error occurred during processing: {e}")
-    finally:
-        if comet_initialized and experiment is not None:
-            try:
-                experiment.end()
-            except Exception as comet_e:
-                st.warning(f"Comet ML experiment.end() failed: {comet_e}")
-        if start_time_overall is not None:
-            end_time_overall = time.time()
-            elapsed_time_overall = end_time_overall - start_time_overall
-            st.info(f"Results processed in **{elapsed_time_overall:.2f} seconds**.")
-        st.write(f"Number of times you requested results: **{st.session_state['source_type_attempts']}/{max_attempts}**")
+                        buf = io.BytesIO()
+                        with zipfile.ZipFile(buf, "w") as myzip:
+                            if not df.empty:
+                                myzip.writestr("Summary_of_results.csv", df.to_csv(index=False))
+                                myzip.writestr("Most_frequent_keyphrases.csv", df_frequent.to_csv(index=False))
+                            myzip.writestr("Glossary_of_tags.csv", dfa.to_csv(index=False))
+
+                        with stylable_container(
+                            key="download_button",
+                            css_styles="""button { background-color: yellow; border: 1px solid black; padding: 5px; color: black; }""",
+                        ):
+                            st.download_button(
+                                label="Download zip file",
+                                data=buf.getvalue(),
+                                file_name="nlpblogs_ner_results.zip",
+                                mime="application/zip",
+                            )
+                        st.divider()
+                    else:
+                        st.warning("No entities found to generate visualizations.")
+            else:
+                st.warning("No meaningful text found to process. Please enter a URL, upload a text file, or type/paste text.")
+        except Exception as e:
+            st.error(f"An unexpected error occurred during processing: {e}")
+        finally:
+            if comet_initialized and experiment is not None:
+                try:
+                    experiment.end()
+                except Exception as comet_e:
+                    st.warning(f"Comet ML experiment.end() failed: {comet_e}")
+            if start_time_overall is not None:
+                end_time_overall = time.time()
+                elapsed_time_overall = end_time_overall - start_time_overall
+                st.info(f"Results processed in **{elapsed_time_overall:.2f} seconds**.")
+            st.write(f"Number of times you requested results: **{st.session_state['source_type_attempts']}/{max_attempts}**")
+    else:
+        st.warning("Please enter some text, a URL, or upload a file to analyze.")