Update app.py

app.py

@@ -381,7 +381,7 @@ def validate_analyst_output(analyst_output):
     return analyst_output
 
 
-# Visualization
+# Visualization and Table Display
 def create_visualizations(analyst_output):
     chart_paths = []
     validated_data = validate_analyst_output(analyst_output)
@@ -392,7 +392,7 @@ def create_visualizations(analyst_output):
             values = item["Values"]
 
             try:
-                # Handle dictionary data for bar/pie charts
+                # Handle dictionary data for bar charts
                 if isinstance(values, dict):
                     df = pd.DataFrame(list(values.items()), columns=["Label", "Count"])
                     if len(df) <= 5:
@@ -402,27 +402,21 @@ def create_visualizations(analyst_output):
 
                 # Handle list data for bar/pie charts
                 elif isinstance(values, list):
-                    # Handle list of dictionaries (e.g., Technology Spotlight)
+                    # Check if it's a list of dictionaries (e.g., Technology Spotlight)
                     if all(isinstance(v, dict) for v in values):
                         df = pd.DataFrame(values)
                         st.subheader(f"{category} (Detailed View)")
                         st.dataframe(df)
-                        # Optional: Generate bar chart for complex data
-                        for col in df.columns:
-                            if pd.api.types.is_numeric_dtype(df[col]):
-                                chart = px.bar(df, x=df.index, y=col, title=f"{category} - {col} Analysis")
-                                st.plotly_chart(chart)
-                                break
-                        continue
-
-                    # Handle simple lists
+                        continue  # Skip chart for detailed data
+
+                    # Frequency analysis for simple lists
                     else:
                         df = pd.DataFrame(values, columns=["Items"])
                         df = df["Items"].value_counts().reset_index()
                         df.columns = ["Label", "Count"]
                         chart = px.pie(df, names="Label", values="Count", title=f"{category} Distribution") if len(df) <= 5 else px.bar(df, x="Label", y="Count", title=f"{category} Frequency")
 
-                # Handle text data
+                # Handle string data (Insights)
                 elif isinstance(values, str):
                     st.subheader(f"{category} Insights")
                     st.table(pd.DataFrame({"Insights": [values]}))
@@ -433,10 +427,10 @@ def create_visualizations(analyst_output):
                     logging.warning(f"Unsupported data format in {category}: {values}")
                     continue
 
-                # Display the chart
+                # Display in Streamlit
                 st.plotly_chart(chart)
 
-                # Save the chart for PDF export
+                # Save 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)
@@ -447,7 +441,6 @@ def create_visualizations(analyst_output):
 
     return chart_paths
 
-
 def display_table(analyst_output):
     table_data = []
     validated_data = validate_analyst_output(analyst_output)
@@ -458,35 +451,34 @@ def display_table(analyst_output):
             values = item["Values"]
 
             try:
-                # Handle dictionary data 
+                # 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"))
 
-                # Handle list data
+                # Handle list data 
                 elif isinstance(values, list):
+                    # Handle complex lists (list of dictionaries)
                     if all(isinstance(v, dict) for v in values):
-                        # Detailed View for list of dictionaries
                         df = pd.DataFrame(values)
                         st.subheader(f"{category} (Detailed View)")
                         st.dataframe(df)
                         table_data.extend(df.to_dict(orient="records"))
+                    # Handle simple lists 
                     else:
-                        # Simple List View
                         df = pd.DataFrame(values, columns=["Items"])
                         st.subheader(f"{category} (List View)")
                         st.dataframe(df)
                         table_data.extend(df.to_dict(orient="records"))
 
-                # Handle string data 
+                # Handle text data
                 elif isinstance(values, str):
                     st.subheader(f"{category} (Summary)")
                     st.table(pd.DataFrame({"Insights": [values]}))
                     table_data.append({"Category": category, "Values": values})
 
-                # Handle unsupported data types
                 else:
                     st.warning(f"Unsupported data format for {category}")
                     logging.warning(f"Unsupported data in {category}: {values}")
@@ -497,37 +489,31 @@ def display_table(analyst_output):
 
     return table_data
 
+
 def parse_analyst_output(raw_output):
     key_insights = []
     data_insights = []
 
     try:
-        # Parse string to Python object if needed
+        # Correctly parse the raw output
         structured_data = ast.literal_eval(raw_output) if isinstance(raw_output, str) else raw_output
 
         for item in structured_data:
             if "Category" not in item or "Values" not in item:
                 logging.warning(f"Missing 'Category' or 'Values' in item: {item}")
-                continue
+                continue  
 
             if item.get("Type") == "Key Insight":
                 key_insights.append(item["Values"])
-
             elif item.get("Type") == "Data Insight":
-                # Flatten nested dictionary structures for visualization
+                # Handle nested structures (e.g., Technology Spotlight Cards)
                 if isinstance(item["Values"], list):
                     for sub_item in item["Values"]:
-                        if isinstance(sub_item, dict):
-                            data_insights.append({"Category": item["Category"], "Values": sub_item})
-                        else:
-                            data_insights.append({"Category": item["Category"], "Values": sub_item})
-                elif isinstance(item["Values"], dict):
-                    data_insights.append(item)
+                        data_insights.append({"Category": item["Category"], "Values": sub_item})
                 else:
                     data_insights.append(item)
-
             else:
-                logging.warning(f"Unrecognized Type in item: {item}")
+                data_insights.append(item)
 
     except Exception as e:
         logging.error(f"Error parsing analyst output: {e}")
@@ -536,40 +522,13 @@ def parse_analyst_output(raw_output):
 
 
 # Main Execution Block
-# Initialize placeholders for outputs to ensure tabs are always visible
-planner_output = "Planner insights will appear here after generating insights."
-analyst_output = "Analyst data will appear here after generating insights."
-writer_output = "Final report will appear here after generating insights."
-charts = []
-table_data = []
-key_insights, data_insights = [], []
-
-# Create tabs at the start so they are always visible
-tab1, tab2, tab3 = st.tabs(["📄 Final Report", "📝 Planner's Insights", "📊 Analyst's Analysis"])
-
-# Final Report Tab (Initial State)
-with tab1:
-    st.header("Final Patent Strategy Report")
-    st.info(writer_output)
-
-# Planner's Insights Tab (Initial State)
-with tab2:
-    st.header("Planner's Research Insights")
-    st.info(planner_output)
-
-# Analyst's Analysis Tab (Initial State)
-with tab3:
-    st.header("Analyst's Data Analysis")
-    st.info(analyst_output)
-
-# Button to Generate Insights
 if st.button("Generate Patent Insights"):
     with st.spinner('Processing...'):
         try:
             # Start the timer
             start_time = time.time()
 
-            # Validate user inputs
+            # Kick off the crew with user inputs
             if not patent_area or not stakeholder:
                 st.error("Please provide both Patent Technology Area and Stakeholder.")
             else:
@@ -579,68 +538,49 @@ if st.button("Generate Patent Insights"):
             # Calculate elapsed time
             elapsed_time = time.time() - start_time
 
-            # Extract Outputs
-            planner_output = getattr(results.tasks_output[0], "raw", "No details available.")
-            analyst_output = getattr(results.tasks_output[1], "raw", "No details available.")
+            # Extract Writer's Output
             writer_output = getattr(results.tasks_output[2], "raw", "No details available.")
+            if writer_output and writer_output.strip():
+                st.markdown("### Final Report")
+                st.write(writer_output)
+            else:
+                st.warning("No final report available.")
 
-            # Parse Analyst Output (Key Insights + Data Insights)
-            if analyst_output and analyst_output.strip():
-                key_insights, data_insights = parse_analyst_output(analyst_output)
-
-                # Create Visualizations if enabled
-                if enable_advanced_analysis and data_insights:
-                    charts = create_visualizations(data_insights)
-                else:
-                    st.info("No data insights available for visualizations.")
-
-                # Display Data Tables
-                table_data = display_table(data_insights)
-
-            # Update Tabs with Results
-
-            # Final Report Tab
-            with tab1:
-                st.header("Final Patent Strategy Report")
-                if writer_output and writer_output.strip():
-                    st.write(writer_output)
-                else:
-                    st.warning("No final report available.")
+            # Expandable section for detailed insights
+            with st.expander("Explore Detailed Insights"):
+                tab1, tab2 = st.tabs(["Planner's Insights", "Analyst's Analysis"])
 
-            # Planner's Insights Tab
-            with tab2:
-                st.header("Planner's Research Insights")
-                if planner_output and planner_output.strip():
-                    st.write(planner_output)
-                else:
-                    st.warning("No planner insights available.")
-
-            # Analyst's Analysis Tab
-            with tab3:
-                st.header("Analyst's Data Analysis")
-                if analyst_output and analyst_output.strip():
-                    st.write(analyst_output)
-
-                    # Structured Analyst Output
-                    st.subheader("Structured Analyst Output")
-                    st.write(data_insights)
-
-                    # Visualizations Section
-                    if charts:
-                        st.subheader("Generated Visualizations")
-                        for chart_path in charts:
-                            st.image(chart_path, use_column_width=True)
+                # Planner's Insights
+                with tab1:
+                    planner_output = getattr(results.tasks_output[0], "raw", "No details available.")
+                    if planner_output and planner_output.strip():
+                        st.write(planner_output)
                     else:
-                        st.info("No visualizations generated.")
+                        st.warning("No planner insights available.")
+
+                # Analyst's Analysis
+                with tab2:
+                    analyst_output = getattr(results.tasks_output[1], "raw", "No details available.")
+                    if analyst_output and analyst_output.strip():
+                        st.write(analyst_output)
+
+                        # Parse Analyst Output (Key Insights + Data Insights)
+                        key_insights, data_insights = parse_analyst_output(analyst_output)
+                        st.subheader("Structured Analyst Output")
+                        st.write(data_insights)
+
+                        # Create Visualizations if enabled
+                        charts = []
+                        if enable_advanced_analysis and data_insights:
+                            charts = create_visualizations(data_insights)
+                        else:
+                            st.info("No data insights available for visualizations.")
+
+                        # Display Data Tables
+                        table_data = display_table(data_insights)
 
-                    # Data Tables Section
-                    if table_data:
-                        st.subheader("Detailed Data Tables")
-                        st.write(table_data)
                     else:
-                        st.info("No data tables generated.")
-                else:
-                    st.warning("No analyst analysis available.")
+                        st.warning("No analyst analysis available.")
 
             # Notify user that the analysis is complete
             st.success(f"Analysis completed in {elapsed_time:.2f} seconds.")
@@ -669,5 +609,4 @@ if st.button("Generate Patent Insights"):
         except Exception as e:
             error_message = traceback.format_exc()
             logging.error(f"An error occurred during execution:\n{error_message}")
-            st.error(f"⚠️ An unexpected error occurred:\n{e}")
-
+            st.error(f"⚠️ An unexpected error occurred:\n{e}")