Update app.py

app.py

@@ -193,6 +193,17 @@ def merge_metadata_with_generated_data(generated_data, excel_metadata):
             generated_data[post_number] = post_data  
     return generated_data
 
+def generate_abstract(text):
+    try:
+        response = llm.chat([
+            {"role": "system", "content": "Generate an abstract and recommendations for the following document."},
+            {"role": "user", "content": text}
+        ])
+        return response["choices"][0]["message"]["content"]
+    except Exception as e:
+        logging.error(f"Groq API error: {e}")
+        return "Abstract generation failed."
+
 def create_docx_from_data(extracted_data):
     doc = Document()
     for post_number, data in extracted_data.items():
@@ -306,127 +317,64 @@ with tabs[0]:
 # -------------------------------------------------------------------
 with tabs[1]:
     st.header("Detailed Analysis of DOCX File")
-    uploaded_docx_analysis = st.file_uploader("Upload DOCX file for detailed analysis", type=["docx"], key="detailed_docx")
+    uploaded_docx_analysis = st.file_uploader("Upload DOCX file", type=["docx"], key="detailed_docx")
     
     if uploaded_docx_analysis:
-        # Extract posts from the uploaded DOCX file
         captions = extract_captions_from_docx(uploaded_docx_analysis)
         total_posts = len(captions)
         st.write(f"**Total number of posts:** {total_posts}")
         
-        # Initialize counters
         language_counter = Counter()
-        tone_counter = Counter()
-        # Prepare a counter dictionary for each frame category across posts
-        frame_overall_counter = {frame: Counter() for frame in frame_categories.keys()}
+        hashtag_counter = Counter()
         
-        # Process each post
         for post, text in captions.items():
-            # Count languages used
             lang = detect_language(text)
             language_counter[lang] += 1
-            
-            # Count tones
-            tones = extract_tone(text)
-            for tone in tones:
-                tone_counter[tone] += 1
-            
-            # Count frames by focus level (Major Focus, Significant Focus, Minor Mention, Not Applicable)
-            frame_mapping = get_frame_category_mapping(text)
-            for frame, category in frame_mapping.items():
-                frame_overall_counter[frame][category] += 1
+            hashtags = extract_hashtags(text)
+            for hashtag in hashtags:
+                hashtag_counter[hashtag] += 1
         
-        # Display aggregated statistics
-        st.subheader("Languages Detected")
+        st.subheader("Language Distribution")
         st.write(dict(language_counter))
         
-        st.subheader("Tone Counts")
-        st.write(dict(tone_counter))
+        st.subheader("Hashtag Distribution")
+        st.write(dict(hashtag_counter))
         
-        st.subheader("Frame Usage Counts")
-        for frame, counts in frame_overall_counter.items():
-            st.write(f"**{frame}:** {dict(counts)}")
-        
-        # Generate an abstract of the document with recommendations using Groq API
         combined_text = " ".join(captions.values())
-        prompt = (
-            "Generate an abstract of the document along with possible reasons behind the observed patterns "
-            "and recommendations for improvement. Document text: " + combined_text
-        )
-        try:
-            response = llm.chat([
-                {"role": "system", "content": "Analyze document abstract and provide recommendations."},
-                {"role": "user", "content": prompt}
-            ])
-            abstract = response["choices"][0]["message"]["content"]
-        except Exception as e:
-            logging.error(f"Groq API error during abstract generation: {e}")
-            st.error("Error generating abstract using Groq API.")
-            abstract = "Abstract generation failed."
-        
-        st.subheader("Abstract and Recommendations")
+        abstract = generate_abstract(combined_text)
+        st.subheader("Abstract & Recommendations")
         st.write(abstract)
         
-        # ---------------------------------------------------------------
-        # Generate downloadable DOCX summary file
-        # ---------------------------------------------------------------
         doc = Document()
-        doc.add_heading("Detailed Analysis Summary", 0)
+        doc.add_heading("Analysis Summary", 0)
         doc.add_paragraph(f"Total number of posts: {total_posts}")
         
-        doc.add_heading("Languages Detected", level=1)
+        doc.add_heading("Language Distribution", level=1)
         for lang, count in language_counter.items():
             doc.add_paragraph(f"{lang}: {count}")
         
-        doc.add_heading("Tone Counts", level=1)
-        for tone, count in tone_counter.items():
-            doc.add_paragraph(f"{tone}: {count}")
+        doc.add_heading("Hashtag Distribution", level=1)
+        for hashtag, count in hashtag_counter.items():
+            doc.add_paragraph(f"{hashtag}: {count}")
         
-        doc.add_heading("Frame Usage Counts", level=1)
-        for frame, counts in frame_overall_counter.items():
-            doc.add_paragraph(f"{frame}: {dict(counts)}")
-        
-        doc.add_heading("Abstract and Recommendations", level=1)
+        doc.add_heading("Abstract & Recommendations", level=1)
         doc.add_paragraph(abstract)
         
-        # Prepare DOCX for download
         docx_io = io.BytesIO()
         doc.save(docx_io)
         docx_io.seek(0)
-        st.download_button(
-            "Download Analysis Summary as DOCX",
-            data=docx_io,
-            file_name="detailed_analysis_summary.docx"
-        )
+        st.download_button("Download Analysis Summary as DOCX", data=docx_io, file_name="analysis_summary.docx")
         
-        # ---------------------------------------------------------------
-        # Generate downloadable Excel summary file with multiple sheets
-        # ---------------------------------------------------------------
         excel_io = io.BytesIO()
         with pd.ExcelWriter(excel_io, engine="xlsxwriter") as writer:
-            # Summary sheet
             df_summary = pd.DataFrame({"Metric": ["Total Posts"], "Value": [total_posts]})
             df_summary.to_excel(writer, sheet_name="Summary", index=False)
             
-            # Languages sheet
             df_lang = pd.DataFrame(list(language_counter.items()), columns=["Language", "Count"])
             df_lang.to_excel(writer, sheet_name="Languages", index=False)
             
-            # Tones sheet
-            df_tone = pd.DataFrame(list(tone_counter.items()), columns=["Tone", "Count"])
-            df_tone.to_excel(writer, sheet_name="Tones", index=False)
-            
-            # Frames sheet: Break down each frame by focus level
-            frame_list = []
-            for frame, counts in frame_overall_counter.items():
-                for category, count in counts.items():
-                    frame_list.append({"Frame": frame, "Category": category, "Count": count})
-            df_frame = pd.DataFrame(frame_list)
-            df_frame.to_excel(writer, sheet_name="Frames", index=False)
-            
+            df_hashtags = pd.DataFrame(list(hashtag_counter.items()), columns=["Hashtag", "Count"])
+            df_hashtags.to_excel(writer, sheet_name="Hashtags", index=False)
+        
         excel_io.seek(0)
-        st.download_button(
-            "Download Analysis Summary as Excel",
-            data=excel_io,
-            file_name="detailed_analysis_summary.xlsx"
-        )
+        st.download_button("Download Analysis Summary as Excel", data=excel_io, file_name="analysis_summary.xlsx")