Update test.py

test.py

@@ -5,28 +5,27 @@ from langchain_groq import ChatGroq
 from fpdf import FPDF
 import pandas as pd
 import plotly.express as px
-import matplotlib.pyplot as plt
 import tempfile
 import time
 
-# Title and Sidebar
+# Title and Application Introduction
 st.title("Patent Insights Consultant")
-
 st.sidebar.write(
     "This Patent Insights Consultant uses a multi-agent system to provide actionable insights and data analysis for the patent domain."
 )
 
-# User Inputs
+# User Input Section
+st.sidebar.header("User Inputs")
 patent_area = st.text_input('Enter Patent Technology Area', value="Transparent Antennas for Windshields")
 stakeholder = st.text_input('Enter Stakeholder', value="Patent Attorneys")
 
 # Advanced Options
-st.sidebar.subheader("Advanced Options")
+st.sidebar.header("Advanced Options")
 enable_advanced_analysis = st.sidebar.checkbox("Enable Advanced Analysis", value=True)
 enable_custom_visualization = st.sidebar.checkbox("Enable Custom Visualizations", value=True)
 
-# Optional Customization
-st.sidebar.subheader("Agent Customization")
+# Agent Customization
+st.sidebar.header("Agent Customization")
 with st.sidebar.expander("Customize Agent Goals", expanded=False):
     enable_customization = st.checkbox("Enable Custom Goals")
     if enable_customization:
@@ -47,15 +46,10 @@ with st.sidebar.expander("Customize Agent Goals", expanded=False):
         writer_goal = "Craft a professional insights document summarizing trends, strategies, and actionable outcomes for stakeholders."
         analyst_goal = "Perform detailed statistical analysis of patent filings, growth trends, and innovation distribution."
 
-#=================
-# LLM Object
-#=================
+# LLM Initialization
 llm = ChatGroq(groq_api_key=os.getenv("GROQ_API_KEY"), model="groq/llama-3.3-70b-versatile")
 
-#=================
-# Crew Agents
-#=================
-
+# Agent Definitions
 planner = Agent(
     role="Patent Research Consultant",
     goal=planner_goal,
@@ -89,10 +83,7 @@ analyst = Agent(
     llm=llm
 )
 
-#=================
-# Crew Tasks
-#=================
-
+# Task Definitions
 plan = Task(
     description=(
         "1. Research recent trends in {topic} patent filings and innovation.\n"
@@ -131,86 +122,84 @@ crew = Crew(
     verbose=True
 )
 
-def generate_pdf_report(result, charts=None, table_data=None):
-    """Generate a professional PDF report from the Crew output."""
+# PDF Report Generation
+
+def generate_pdf_report(result, charts=None, table_data=None, metadata=None):
     with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
         pdf = FPDF()
         pdf.add_page()
         pdf.set_font("Arial", size=12)
         pdf.set_auto_page_break(auto=True, margin=15)
 
-        # Title
         pdf.set_font("Arial", size=16, style="B")
         pdf.cell(200, 10, txt="Patent Insights Report", ln=True, align="C")
         pdf.ln(10)
 
-        # Content
+        if metadata:
+            pdf.set_font("Arial", size=10)
+            for key, value in metadata.items():
+                pdf.cell(200, 10, txt=f"{key}: {value}", ln=True)
+
         pdf.set_font("Arial", size=12)
         pdf.multi_cell(0, 10, txt=result)
 
-        # Add charts if provided
         if charts:
             for chart_path in charts:
                 pdf.add_page()
                 pdf.image(chart_path, x=10, y=20, w=180)
 
-        # Add tables if provided
         if table_data:
             pdf.add_page()
             pdf.set_font("Arial", size=10)
             for row in table_data:
                 pdf.cell(200, 10, txt=str(row), ln=True)
 
-        # Save PDF
         pdf.output(temp_pdf.name)
         return temp_pdf.name
 
+# Data Validation
+
+def validate_analyst_output(analyst_output):
+    if not analyst_output:
+        st.warning("No data available for analysis.")
+        return None
+    if not isinstance(analyst_output, list) or not all(isinstance(item, dict) for item in analyst_output):
+        st.warning("Analyst output must be a list of dictionaries.")
+        return None
+    required_keys = {'Category', 'Values'}
+    if not all(required_keys.issubset(item.keys()) for item in analyst_output):
+        st.warning(f"Each dictionary must contain keys: {required_keys}")
+        return None
+    return analyst_output
+
+# Visualization and Table Display
+
 def create_visualizations(analyst_output):
-    """Create visualizations for advanced insights."""
     chart_paths = []
-    if enable_custom_visualization and analyst_output:
+    validated_data = validate_analyst_output(analyst_output)
+    if validated_data:
+        data = pd.DataFrame(validated_data)
         try:
-            st.markdown("#### Debugging Analyst Output")
-            st.write(analyst_output)
-
-            # Validate and format analyst output
-            if isinstance(analyst_output, list) and all(isinstance(item, dict) for item in analyst_output):
-                data = pd.DataFrame(analyst_output)
-                if 'Category' in data.columns and 'Values' in data.columns:
-                    st.markdown("### Advanced Visualization")
-
-                    # Create a bar chart
-                    fig = px.bar(data, x="Category", y="Values", title="Patent Trends by Category")
-                    st.plotly_chart(fig)
-
-                    # Save chart to a file for embedding in PDF
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_chart:
-                        fig.write_image(temp_chart.name)
-                        chart_paths.append(temp_chart.name)
-                else:
-                    st.warning("Data does not have the required columns 'Category' and 'Values'.")
-            else:
-                st.warning("Analyst output is not in the correct format for visualization.")
+            fig = px.bar(data, x="Category", y="Values", title="Patent Trends by Category")
+            st.plotly_chart(fig)
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_chart:
+                fig.write_image(temp_chart.name)
+                chart_paths.append(temp_chart.name)
         except Exception as e:
-            st.error(f"Failed to create visualizations: {e}")
+            st.error(f"Error generating visualization: {e}")
     return chart_paths
 
 def display_table(analyst_output):
-    """Display tabular data for detailed insights."""
     table_data = []
-    if analyst_output and isinstance(analyst_output, list):
-        try:
-            st.markdown("#### Debugging Analyst Output for Table")
-            st.write(analyst_output)
-
-            data = pd.DataFrame(analyst_output)
-            st.markdown("### Data Table")
-            st.dataframe(data)
-            table_data = data.to_dict(orient="records")
-        except Exception as e:
-            st.error(f"Failed to display table: {e}")
+    validated_data = validate_analyst_output(analyst_output)
+    if validated_data:
+        data = pd.DataFrame(validated_data)
+        st.dataframe(data)
+        table_data = data.to_dict(orient="records")
     return table_data
 
+# Main Execution Block
+
 if st.button("Generate Patent Insights"):
     with st.spinner('Processing...'):
         try:
@@ -218,50 +207,34 @@ if st.button("Generate Patent Insights"):
             results = crew.kickoff(inputs={"topic": patent_area, "stakeholder": stakeholder})
             elapsed_time = time.time() - start_time
 
-            # Display Final Report (Writer's Output)
-            st.markdown("### Final Report:")
             writer_output = getattr(results.tasks_output[2], "raw", "No details available.")
             if writer_output:
+                st.markdown("### Final Report")
                 st.write(writer_output)
             else:
                 st.warning("No final report available.")
 
-            # Option for Detailed Insights
             with st.expander("Explore Detailed Insights"):
                 tab1, tab2 = st.tabs(["Planner's Insights", "Analyst's Analysis"])
 
-                # Planner's Output
                 with tab1:
-                    st.markdown("### Planner's Insights")
                     planner_output = getattr(results.tasks_output[0], "raw", "No details available.")
                     st.write(planner_output)
 
-                # Analyst's Output
                 with tab2:
-                    st.markdown("### Analyst's Analysis")
                     analyst_output = getattr(results.tasks_output[1], "raw", "No details available.")
                     st.write(analyst_output)
 
-                    # Generate visualizations if enabled
                     charts = []
                     if enable_advanced_analysis:
                         charts = create_visualizations(analyst_output)
 
-                    # Display tabular data
                     table_data = display_table(analyst_output)
 
-            # Display Token Usage and Execution Time
             st.success(f"Analysis completed in {elapsed_time:.2f} seconds.")
-            token_usage = getattr(results, "token_usage", None)
-            if token_usage:
-                st.markdown("#### Token Usage")
-                st.json(token_usage)
-
-            # Generate PDF Report
-            if writer_output:
-                pdf_path = generate_pdf_report(writer_output, charts=charts, table_data=table_data)
-                with open(pdf_path, "rb") as report_file:
-                    st.download_button("Download Report", data=report_file, file_name="Patent_Report.pdf")
+            pdf_path = generate_pdf_report(writer_output, charts=charts, table_data=table_data, metadata={"Technology Area": patent_area, "Stakeholder": stakeholder})
+            with open(pdf_path, "rb") as report_file:
+                st.download_button("Download Report", data=report_file, file_name="Patent_Report.pdf")
 
         except Exception as e:
             st.error(f"An error occurred during execution: {e}")