Update app.py

app.py

@@ -9,6 +9,7 @@ import pandas as pd
 import plotly.express as px
 import tempfile
 import time
+import ast
 import logging
 
 # Setup logging
@@ -241,38 +242,56 @@ def create_visualizations(analyst_output):
             category = item["Category"]
             values = item["Values"]
 
-            # Handle dictionary-type data for bar charts
-            if isinstance(values, dict):
-                df = pd.DataFrame(list(values.items()), columns=["Label", "Count"])
-                chart = px.bar(df, x="Label", y="Count", title=f"{category} Analysis")
+            try:
+                # Handle dictionary data
+                if isinstance(values, dict):
+                    df = pd.DataFrame(list(values.items()), columns=["Label", "Count"])
 
-            # Handle list-type data for pie charts
-            elif isinstance(values, list):
-                df = pd.DataFrame(values, columns=["Label"])
-                df["Count"] = 1  # Assign count for visualization
-                chart = px.pie(df, names="Label", values="Count", title=f"{category} Distribution")
+                    # Choose Pie Chart for fewer categories, else Bar Chart
+                    if len(df) <= 5:
+                        chart = px.pie(df, names="Label", values="Count", title=f"{category} Distribution")
+                    else:
+                        chart = px.bar(df, x="Label", y="Count", title=f"{category} Analysis")
 
-            # Handle text data by converting it into a simple table
-            elif isinstance(values, str):
-                st.subheader(f"{category} Insights")
-                st.table(pd.DataFrame({"Insights": [values]}))
-                continue  # Skip visualization for text data
+                # Handle list data 
+                elif isinstance(values, list):
+                    # Convert the list into a frequency count without dummy values
+                    df = pd.DataFrame(values, columns=["Label"])
+                    df = df["Label"].value_counts().reset_index()
+                    df.columns = ["Label", "Count"]
+
+                    # Plot as a bar chart or pie chart
+                    if len(df) <= 5:
+                        chart = px.pie(df, names="Label", values="Count", title=f"{category} Distribution")
+                    else:
+                        chart = px.bar(df, x="Label", y="Count", title=f"{category} Frequency")
+
+                # Handle text data
+                elif isinstance(values, str):
+                    st.subheader(f"{category} Insights")
+                    st.table(pd.DataFrame({"Insights": [values]}))
+                    continue  # No chart for text data
 
-            else:
-                st.warning(f"Unsupported data format in category: {category}")
-                continue
+                else:
+                    st.warning(f"Unsupported data format for category: {category}")
+                    continue
+
+                # Display the chart in Streamlit
+                st.plotly_chart(chart)
 
-            # Display the chart in Streamlit
-            st.plotly_chart(chart)
+                # Save the chart for PDF export
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_chart:
+                    chart.write_image(temp_chart.name)
+                    chart_paths.append(temp_chart.name)
 
-            # Save the chart for PDF generation
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_chart:
-                chart.write_image(temp_chart.name)
-                chart_paths.append(temp_chart.name)
+            except Exception as e:
+                st.error(f"Failed to generate visualization for {category}: {e}")
+                logging.error(f"Error in {category} visualization: {e}")
 
     return chart_paths
 
 
+
 def display_table(analyst_output):
     table_data = []
     validated_data = validate_analyst_output(analyst_output)
@@ -282,22 +301,23 @@ def display_table(analyst_output):
             category = item["Category"]
             values = item["Values"]
 
+            # Error handling to prevent crashes
             try:
-                # Dictionary → Structured Table
+                # Handle dictionary data (Table View)
                 if isinstance(values, dict):
                     df = pd.DataFrame(list(values.items()), columns=["Label", "Count"])
                     st.subheader(f"{category} (Table View)")
                     st.dataframe(df)
                     table_data.extend(df.to_dict(orient="records"))
 
-                # List → Simple List Table
+                # Handle list data (List View)
                 elif isinstance(values, list):
                     df = pd.DataFrame(values, columns=["Items"])
                     st.subheader(f"{category} (List View)")
                     st.dataframe(df)
                     table_data.extend(df.to_dict(orient="records"))
 
-                # String → Text Table
+                # Handle text data (Summary View)
                 elif isinstance(values, str):
                     st.subheader(f"{category} (Summary)")
                     st.table(pd.DataFrame({"Insights": [values]}))
@@ -307,49 +327,51 @@ def display_table(analyst_output):
                     st.warning(f"Unsupported data format for category: {category}")
 
             except Exception as e:
-                logging.error(f"Error displaying {category} as table: {e}")
-                st.error(f"Failed to display {category} as a table.")
+                logging.error(f"Error processing {category}: {e}")
+                st.error(f"Failed to display {category} as a table due to an error.")
 
     return table_data
 
 
+
 def parse_analyst_output(raw_output):
     structured_data = []
     current_category = None
     current_values = []
 
+    # Split raw output by line
     lines = raw_output.split('\n')
 
     for line in lines:
         line = line.strip()
 
-        # Detect new category
+        # Detect the start of a new category
         if line.startswith("Category:"):
-            # Save previous category if exists
+            # Save the previous category and its values
             if current_category and current_values:
                 structured_data.append({
                     "Category": current_category,
                     "Values": current_values if len(current_values) > 1 else current_values[0]
                 })
-            # Start new category
+            # Start processing the new category
             current_category = line.replace("Category:", "").strip()
             current_values = []
 
-        # Detect start of values
+        # Skip 'Values:' header
         elif line.startswith("Values:"):
             continue
 
-        # Handle content under a category
+        # Process the values under the current category
         elif line and current_category:
             try:
-                # Attempt to parse the line as a dictionary or list
+                # Attempt to convert the line into Python data (dict/list)
                 parsed_value = ast.literal_eval(line)
                 current_values.append(parsed_value)
             except (ValueError, SyntaxError):
                 # If parsing fails, treat it as plain text
                 current_values.append(line)
 
-    # Save the last category
+    # Save the last processed category
     if current_category and current_values:
         structured_data.append({
             "Category": current_category,