Create utils.py

utils.py

@@ -1,132 +1,91 @@
 # utils.py
+import re
 import json
-from datetime import datetime
 import streamlit as st
-import plotly.graph_objects as go
-import plotly.express as px
-import re
-import pdfkit
-from jinja2 import Template
-
-class ReportManager:
-    def __init__(self):
-        if 'reports' not in st.session_state:
-            st.session_state.reports = {}
-
-    def save_report(self, topic: str, report_data: dict):
-        """Save a new report with timestamp"""
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        report_id = f"{topic}_{timestamp}"
-        
-        st.session_state.reports[report_id] = {
-            'topic': topic,
-            'timestamp': timestamp,
-            'exec_summary': report_data.get('exec_summary', ''),
-            'detailed_report': report_data.get('detailed_report', ''),
-            'sources': report_data.get('sources', []),
-            'charts': report_data.get('charts', [])
-        }
-        return report_id
-
-    def get_report(self, report_id: str):
-        """Retrieve a specific report"""
-        return st.session_state.reports.get(report_id)
 
-    def get_all_reports(self):
-        """Get all saved reports"""
-        return st.session_state.reports
+def update_progress(container, percentage, message=""):
+    """Update the progress bar"""
+    progress_html = f"""
+        <div class="progress-container">
+            <div class="progress-bar" style="width: {percentage}%">{message}</div>
+        </div>
+    """
+    container.markdown(progress_html, unsafe_allow_html=True)
 
-    def generate_visualizations(self, report_text: str):
-        """Generate relevant visualizations based on report content"""
-        charts = []
-        
-        # Extract numerical data using regex patterns
-        market_size_pattern = r"\$\s*(\d+(?:\.\d+)?)\s*(?:billion|million|trillion)"
-        growth_rate_pattern = r"(\d+(?:\.\d+)?)\s*%"
-        
-        # Market size data
-        market_sizes = re.findall(market_size_pattern, report_text)
-        if market_sizes:
-            fig = go.Figure(data=[
-                go.Bar(
-                    x=['Current Market Size', 'Projected Size'],
-                    y=[float(market_sizes[0]), float(market_sizes[-1])],
-                    text=[f'${x}B' for x in market_sizes],
-                    textposition='auto',
-                )
-            ])
-            fig.update_layout(title='Market Size Projection')
-            charts.append(fig)
+def extract_section(text, section_name):
+    """Extract a section from the text"""
+    pattern = f"{section_name}.*?\n(.*?)(?=\n\n|$)"
+    match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+    if match:
+        return match.group(1).strip()
+    
+    pattern2 = f"{section_name}[:\s](.*?)(?=\n\n|$)"
+    match = re.search(pattern2, text, re.DOTALL | re.IGNORECASE)
+    return match.group(1).strip() if match else "Information not found"
 
-        # Growth rate data
-        growth_rates = re.findall(growth_rate_pattern, report_text)
-        if growth_rates:
-            fig = go.Figure(data=[
-                go.Line(
-                    x=list(range(len(growth_rates))),
-                    y=[float(x) for x in growth_rates],
-                    mode='lines+markers'
-                )
-            ])
-            fig.update_layout(title='Growth Rate Trends')
-            charts.append(fig)
+def extract_sources(text):
+    """Extract sources from the text"""
+    sources = []
+    patterns = [
+        r"Source:.*?(?:\n|$)",
+        r"\[.*?\]",
+        r"\(https?://.*?\)",
+        r"Reference:.*?(?:\n|$)"
+    ]
+    
+    for pattern in patterns:
+        matches = re.finditer(pattern, text, re.MULTILINE)
+        sources.extend([match.group().strip() for match in matches])
+    
+    return sources if sources else ["Sources not explicitly mentioned"]
 
-        return charts
+def format_json_output(raw_output):
+    """Format CrewOutput into proper JSON structure"""
+    try:
+        if hasattr(raw_output, 'raw_output'):
+            raw_text = str(raw_output.raw_output)
+        else:
+            raw_text = str(raw_output)
 
-    def generate_pdf(self, report_id: str):
-        """Generate PDF version of the report"""
-        report = self.get_report(report_id)
-        if not report:
-            return None
+        # Try to find JSON structure
+        json_pattern = r"\{[\s\S]*\}"
+        match = re.search(json_pattern, raw_text)
+        if match:
+            try:
+                return json.loads(match.group())
+            except:
+                pass
 
-        # HTML template for PDF
-        template_str = """
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <style>
-                body { font-family: Arial, sans-serif; }
-                .header { text-align: center; margin-bottom: 30px; }
-                .section { margin: 20px 0; }
-                .charts { text-align: center; }
-            </style>
-        </head>
-        <body>
-            <div class="header">
-                <h1>{{ report.topic }} - Market Research Report</h1>
-                <p>Generated on: {{ report.timestamp }}</p>
-            </div>
-            
-            <div class="section">
-                <h2>Executive Summary</h2>
-                {{ report.exec_summary }}
-            </div>
-
-            <div class="section">
-                <h2>Detailed Analysis</h2>
-                {{ report.detailed_report }}
-            </div>
-
-            <div class="section">
-                <h2>Sources</h2>
-                <ul>
-                {% for source in report.sources %}
-                    <li>{{ source }}</li>
-                {% endfor %}
-                </ul>
-            </div>
-        </body>
-        </html>
-        """
-
-        # Render template
-        template = Template(template_str)
-        html = template.render(report=report)
-
-        # Convert to PDF
-        try:
-            pdf = pdfkit.from_string(html, False)
-            return pdf
-        except Exception as e:
-            st.error(f"Error generating PDF: {str(e)}")
-            return None
+        # Create structured format
+        return {
+            "exec_summary": {
+                "summary": extract_section(raw_text, "Executive Summary"),
+                "market_size": extract_section(raw_text, "Market Size"),
+                "growth_rate": extract_section(raw_text, "Growth Rate"),
+                "key_players": extract_section(raw_text, "Key Players")
+            },
+            "detailed_report": raw_text,
+            "sources": extract_sources(raw_text),
+            "metrics": {
+                "market_size_data": [],
+                "growth_rates": [],
+                "market_shares": {}
+            }
+        }
+    except Exception as e:
+        st.error(f"Error formatting output: {str(e)}")
+        return {
+            "exec_summary": {
+                "summary": "Error formatting report",
+                "market_size": "N/A",
+                "growth_rate": "N/A",
+                "key_players": "N/A"
+            },
+            "detailed_report": raw_text if 'raw_text' in locals() else str(raw_output),
+            "sources": [],
+            "metrics": {
+                "market_size_data": [],
+                "growth_rates": [],
+                "market_shares": {}
+            }
+        }