Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 import json
+import re
 from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification
 import torch
 
@@ -9,7 +10,6 @@ class FinancialAnalyzer:
     def __init__(self):
         print("Initializing Financial Analyzer...")
         self.initialize_models()
-        self.initialize_benchmarks()
 
     def initialize_models(self):
         print("Loading models...")
@@ -20,212 +20,151 @@ class FinancialAnalyzer:
         self.finbert_model = AutoModelForSequenceClassification.from_pretrained("ProsusAI/finbert")
         print("Models loaded successfully!")
 
-    def initialize_benchmarks(self):
-        self.industry_benchmarks = {
-            "Liquidity": {
-                "Current Ratio": 2.0,
-                "Quick Ratio": 1.0
-            },
-            "Profitability": {
-                "Gross Margin": 40.0,
-                "Operating Margin": 15.0,
-                "Net Margin": 10.0
-            },
-            "Efficiency": {
-                "Asset Turnover": 2.0,
-                "Inventory Turnover": 6.0
-            }
-        }
-
-    def clean_number(self, value):
-        """Clean numerical values from files (all in thousands)"""
-        if isinstance(value, str):
-            # Remove currency symbols, commas, spaces and handle parentheses
-            value = value.replace(',', '').replace('$', '').replace(' ', '')
-            value = value.replace('(', '-').replace(')', '')
-        try:
-            return float(value)
-        except:
-            return 0.0
-
-    def calculate_metrics(self, balance_sheet_df, income_stmt_df):
-        """Calculate financial metrics (all values in thousands)"""
-        metrics = {}
-        years = [str(year) for year in range(2021, 2026)]
+    def parse_markdown_table(self, markdown_content):
+        """Parse markdown table into pandas DataFrame"""
+        # Split content into lines
+        lines = markdown_content.strip().split('\n')
         
-        for year in years:
-            try:
-                # Balance Sheet metrics
-                total_current_assets = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Total_Type'] == 'Total_Current_Assets', year].iloc[0])
-                total_assets = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Total_Type'] == 'Total_Assets', year].iloc[0])
-                total_current_liabilities = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Total_Type'] == 'Total_Current_Liabilities', year].iloc[0])
-                total_liabilities = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Total_Type'] == 'Total_Liabilities', year].iloc[0])
-                total_equity = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Total_Type'] == 'Total_Shareholders_Equity', year].iloc[0])
-                inventory = self.clean_number(balance_sheet_df.loc[balance_sheet_df['Account'] == 'Inventory', year].iloc[0])
-
-                # Income Statement metrics
-                revenue = self.clean_number(income_stmt_df.loc[income_stmt_df.get('Revenue Items') == 'Total Net Revenue', year].iloc[0])
-                gross_profit = self.clean_number(income_stmt_df.loc[income_stmt_df.get('Item') == 'Gross Profit', year].iloc[0])
-                operating_expenses = self.clean_number(income_stmt_df.loc[income_stmt_df.get('Expense Category') == 'Total Operating Expenses', year].iloc[0])
-                ebit = self.clean_number(income_stmt_df.loc[income_stmt_df.get('Item') == 'EBIT', year].iloc[0])
-                net_earnings = self.clean_number(income_stmt_df.loc[income_stmt_df.get('Item') == 'Net Earnings', year].iloc[0])
-
-                metrics[year] = {
-                    "Liquidity": {
-                        "Current Ratio": round(total_current_assets / total_current_liabilities, 2) if total_current_liabilities != 0 else 0,
-                        "Quick Ratio": round((total_current_assets - inventory) / total_current_liabilities, 2) if total_current_liabilities != 0 else 0
-                    },
-                    "Profitability": {
-                        "Gross Margin": round((gross_profit / revenue * 100), 2) if revenue != 0 else 0,
-                        "Operating Margin": round((ebit / revenue * 100), 2) if revenue != 0 else 0,
-                        "Net Margin": round((net_earnings / revenue * 100), 2) if revenue != 0 else 0,
-                        "ROE": round((net_earnings / total_equity * 100), 2) if total_equity != 0 else 0,
-                        "ROA": round((net_earnings / total_assets * 100), 2) if total_assets != 0 else 0
-                    },
-                    "Efficiency": {
-                        "Asset Turnover": round(revenue / total_assets, 2) if total_assets != 0 else 0,
-                        "Inventory Turnover": round(operating_expenses / inventory, 2) if inventory != 0 else 0
-                    },
-                    "Leverage": {
-                        "Debt to Equity": round(total_liabilities / total_equity, 2) if total_equity != 0 else 0,
-                        "Debt Ratio": round(total_liabilities / total_assets, 2) if total_assets != 0 else 0
-                    },
-                    "Growth": {
-                        "Revenue": None if year == '2021' else
-                            round(((revenue - self.clean_number(income_stmt_df.loc[income_stmt_df.get('Revenue Items') == 'Total Net Revenue', str(int(year)-1)].iloc[0])) /
-                             self.clean_number(income_stmt_df.loc[income_stmt_df.get('Revenue Items') == 'Total Net Revenue', str(int(year)-1)].iloc[0]) * 100), 2)
-                    }
-                }
-
-                # Add key absolute values (in thousands)
-                metrics[year]["Key Values"] = {
-                    "Total Assets": total_assets,
-                    "Total Liabilities": total_liabilities,
-                    "Total Equity": total_equity,
-                    "Revenue": revenue,
-                    "Net Earnings": net_earnings
-                }
-
-            except Exception as e:
-                print(f"Error calculating metrics for year {year}: {str(e)}")
-                metrics[year] = "Error in calculation"
-
-        return metrics
-
-    def create_insights_prompt(self, metrics, balance_sheet, income_stmt):
-        latest_year_metrics = metrics['2025']
-        return f"""<human>Analyze these financial statements (all values in thousands) and provide detailed insights:
-
-Key Metrics for Latest Year (2025):
-- Current Ratio: {latest_year_metrics['Liquidity']['Current Ratio']}
-- Net Margin: {latest_year_metrics['Profitability']['Net Margin']}%
-- Revenue: {latest_year_metrics['Key Values']['Revenue']:,.0f}
-- Net Earnings: {latest_year_metrics['Key Values']['Net Earnings']:,.0f}
-
-Balance Sheet Trends:
-{balance_sheet[:800]}
-
-Income Statement Trends:
-{income_stmt[:800]}
-
-Provide specific analysis on:
-1. Financial Health and Stability
-2. Profitability and Efficiency
-3. Growth Trends and Patterns
-4. Risk Factors and Concerns
-5. Strategic Recommendations
-6. Future Outlook</human>"""
-
-    def generate_ai_insights(self, prompt):
-        inputs = self.tiny_tokenizer(prompt, return_tensors="pt", truncation=True)
-        outputs = self.tiny_model.generate(
-            inputs["input_ids"],
-            max_length=1000,
-            temperature=0.7,
-            top_p=0.95,
-            do_sample=True
-        )
-        return self.tiny_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-    def analyze_sentiment(self, metrics):
-        latest_metrics = json.dumps(metrics['2025'])
-        inputs = self.finbert_tokenizer(latest_metrics, return_tensors="pt", truncation=True)
-        outputs = self.finbert_model(**inputs)
-        probs = torch.nn.functional.softmax(outputs.logits, dim=1)
-        sentiment_labels = ['negative', 'neutral', 'positive']
+        # Find table start (line with |)
+        table_lines = []
+        headers = None
+        current_table = []
         
-        return {
-            'sentiment': sentiment_labels[probs.argmax().item()],
-            'confidence': f"{probs.max().item():.2f}"
-        }
-
-    def generate_roadmap(self, metrics):
-        latest_metrics = metrics['2025']
-        roadmap = {
-            "Immediate Actions (0-6 months)": [],
-            "Short-term Goals (6-12 months)": [],
-            "Medium-term Strategy (1-2 years)": [],
-            "Long-term Vision (3-5 years)": []
-        }
-
-        # Generate recommendations based on metrics comparison
-        current_ratio = latest_metrics["Liquidity"]["Current Ratio"]
-        net_margin = latest_metrics["Profitability"]["Net Margin"]
-        asset_turnover = latest_metrics["Efficiency"]["Asset Turnover"]
-
-        # Add specific recommendations based on metric analysis
-        if current_ratio > self.industry_benchmarks["Liquidity"]["Current Ratio"] * 1.5:
-            roadmap["Short-term Goals (6-12 months)"].append("Consider optimizing excess working capital")
-        elif current_ratio < self.industry_benchmarks["Liquidity"]["Current Ratio"]:
-            roadmap["Immediate Actions (0-6 months)"].append("Improve working capital management")
-
-        if net_margin < self.industry_benchmarks["Profitability"]["Net Margin"]:
-            roadmap["Immediate Actions (0-6 months)"].append("Review cost structure")
-            roadmap["Short-term Goals (6-12 months)"].append("Implement margin improvement initiatives")
-
-        if asset_turnover < self.industry_benchmarks["Efficiency"]["Asset Turnover"]:
-            roadmap["Medium-term Strategy (1-2 years)"].append("Optimize asset utilization")
-            roadmap["Long-term Vision (3-5 years)"].append("Consider strategic asset restructuring")
-
-        return roadmap
+        for line in lines:
+            if '|' in line:
+                # Skip separator lines (contains ---)
+                if '-|-' in line:
+                    continue
+                # Clean and split the line
+                row = [cell.strip() for cell in line.split('|')[1:-1]]
+                if headers is None:
+                    headers = row
+                else:
+                    current_table.append(row)
+                    
+        # Create DataFrame
+        df = pd.DataFrame(current_table, columns=headers)
+        return df
+
+    def extract_financial_data(self, markdown_content):
+        """Convert markdown content to a structured text format"""
+        # Remove markdown formatting
+        clean_text = markdown_content.replace('#', '').replace('*', '')
+        
+        # Extract tables
+        tables = {}
+        current_section = "General"
+        
+        for line in clean_text.split('\n'):
+            if line.strip() and not line.startswith('|'):
+                current_section = line.strip()
+            elif '|' in line:
+                if current_section not in tables:
+                    tables[current_section] = []
+                tables[current_section].append(line)
+                
+        # Convert to text format
+        structured_text = []
+        for section, content in tables.items():
+            structured_text.append(f"\n{section}:")
+            if content:
+                df = self.parse_markdown_table('\n'.join(content))
+                structured_text.append(df.to_string())
+                
+        return '\n'.join(structured_text)
 
     def analyze_financials(self, balance_sheet_file, income_stmt_file):
+        """Main analysis function"""
         try:
-            # Read files
-            balance_sheet_df = pd.read_csv(balance_sheet_file)
-            income_stmt_df = pd.read_csv(income_stmt_file)
-            
-            # Also read raw content for context
+            # Read markdown files
             with open(balance_sheet_file, 'r') as f:
                 balance_sheet_content = f.read()
             with open(income_stmt_file, 'r') as f:
                 income_stmt_content = f.read()
 
-            # Calculate metrics
-            metrics = self.calculate_metrics(balance_sheet_df, income_stmt_df)
-            
-            # Generate insights
-            insights_prompt = self.create_insights_prompt(metrics, balance_sheet_content, income_stmt_content)
-            insights = self.generate_ai_insights(insights_prompt)
-            
-            # Generate sentiment and roadmap
-            sentiment = self.analyze_sentiment(metrics)
-            roadmap = self.generate_roadmap(metrics)
-
-            # Compile analysis
-            analysis = {
-                "Financial Metrics": metrics,
-                "AI Insights": insights,
+            # Convert to structured text
+            structured_balance = self.extract_financial_data(balance_sheet_content)
+            structured_income = self.extract_financial_data(income_stmt_content)
+
+            # Create analysis prompt
+            prompt = f"""<human>Please analyze these financial statements and provide detailed insights:
+
+Financial Statements Analysis (2021-2025)
+
+Balance Sheet Summary:
+{structured_balance}
+
+Income Statement Summary:
+{structured_income}
+
+Please provide a detailed analysis including:
+1. Financial Health Assessment
+   - Liquidity position
+   - Capital structure
+   - Asset efficiency
+
+2. Profitability Analysis
+   - Revenue trends
+   - Cost management
+   - Profit margins
+
+3. Growth Analysis
+   - Year-over-year growth rates
+   - Market position
+   - Future growth potential
+
+4. Risk Assessment
+   - Operating risks
+   - Financial risks
+   - Strategic risks
+
+5. Recommendations
+   - Short-term actions
+   - Medium-term strategy
+   - Long-term planning
+
+6. Future Outlook
+   - Market conditions
+   - Company positioning
+   - Growth opportunities</human>"""
+
+            # Generate AI analysis
+            inputs = self.tiny_tokenizer(prompt, return_tensors="pt", truncation=True)
+            outputs = self.tiny_model.generate(
+                inputs["input_ids"],
+                max_length=2048,
+                temperature=0.7,
+                top_p=0.95,
+                do_sample=True
+            )
+            analysis = self.tiny_tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+            # Generate sentiment
+            sentiment = self.analyze_sentiment(structured_balance + structured_income)
+
+            # Compile results
+            results = {
+                "Financial Analysis": analysis,
                 "Sentiment Analysis": sentiment,
-                "Strategic Roadmap": roadmap,
                 "Analysis Period": "2021-2025",
-                "Note": "All values in thousands"
+                "Note": "All values in millions ($M)"
             }
 
-            return json.dumps(analysis, indent=2)
+            return json.dumps(results, indent=2)
 
         except Exception as e:
-            return f"Error in analysis: {str(e)}"
+            return f"Error in analysis: {str(e)}\n\nDetails: {type(e).__name__}"
+
+    def analyze_sentiment(self, text):
+        inputs = self.finbert_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+        outputs = self.finbert_model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=1)
+        sentiment_labels = ['negative', 'neutral', 'positive']
+        
+        return {
+            'sentiment': sentiment_labels[probs.argmax().item()],
+            'confidence': f"{probs.max().item():.2f}"
+        }
 
 def create_interface():
     analyzer = FinancialAnalyzer()
@@ -233,12 +172,12 @@ def create_interface():
     iface = gr.Interface(
         fn=analyzer.analyze_financials,
         inputs=[
-            gr.File(label="Balance Sheet (CSV)", type="filepath"),
-            gr.File(label="Income Statement (CSV)", type="filepath")
+            gr.File(label="Balance Sheet (Markdown)", type="filepath"),
+            gr.File(label="Income Statement (Markdown)", type="filepath")
         ],
         outputs=gr.Textbox(label="Analysis Results", lines=25),
         title="Financial Statement Analyzer",
-        description="Upload financial statements for comprehensive analysis including AI insights, sentiment analysis, and strategic roadmap. (All values in thousands)"
+        description="Upload financial statements in Markdown format for comprehensive AI-powered analysis."
     )
     
     return iface