Update app.py

app.py

@@ -4,9 +4,7 @@ import pandas as pd
 import torch
 import logging
 import gc
-import re
 from transformers import pipeline
-from typing import Dict, List, Tuple, Optional
 
 # Setup logging
 logging.basicConfig(
@@ -19,13 +17,19 @@ logger = logging.getLogger(__name__)
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 logger.info(f"Using device: {DEVICE}")
 
+def clear_gpu_memory():
+    """Utility function to clear GPU memory"""
+    if DEVICE == "cuda":
+        torch.cuda.empty_cache()
+    gc.collect()
+
 class FinancialDataExtractor:
-    """Extracts and processes financial data from raw CSV files"""
+    """Extract and clean financial data"""
     
     def __init__(self):
-        self.numeric_pattern = re.compile(r'[^\d.-]+')
+        self.logger = logger
         
-    def clean_number(self, value: str) -> float:
+    def clean_number(self, value):
         """Clean numeric values from financial statements"""
         try:
             if pd.isna(value) or value == '' or value == '-':
@@ -34,7 +38,7 @@ class FinancialDataExtractor:
                 return float(value)
             
             # Remove currency symbols, spaces, commas
-            cleaned = str(value).replace('$', '').replace(',', '').strip()
+            cleaned = str(value).replace('$', '').replace(',', '').replace('"', '').strip()
             # Handle parentheses for negative numbers
             if '(' in cleaned and ')' in cleaned:
                 cleaned = '-' + cleaned.replace('(', '').replace(')', '')
@@ -42,74 +46,25 @@ class FinancialDataExtractor:
         except:
             return 0.0
 
-    def process_income_statement(self, df: pd.DataFrame) -> Dict:
-        """Process income statement data"""
-        metrics = {}
-        years = [col for col in df.columns if str(col).isdigit()]
+    def extract_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Extract and clean data from DataFrame"""
+        # Clean column names
+        df.columns = df.columns.str.strip()
         
-        for year in years:
-            metrics[year] = {
-                'Revenue': 0,
-                'Expenses': 0,
-                'Profit': 0,
-                'Details': {}
-            }
-            
-            # Extract revenue
-            total_revenue = df[df.iloc[:, 0].str.contains('Total Net Revenue|Revenue', na=False, regex=True)].iloc[0][year]
-            metrics[year]['Revenue'] = self.clean_number(total_revenue)
-            
-            # Extract expenses
-            total_expenses = df[df.iloc[:, 0].str.contains('Total Expenses', na=False)].iloc[0][year]
-            metrics[year]['Expenses'] = self.clean_number(total_expenses)
-            
-            # Extract profit
-            net_income = df[df.iloc[:, 0].str.contains('Net Income|Net Earnings', na=False, regex=True)].iloc[-1][year]
-            metrics[year]['Profit'] = self.clean_number(net_income)
-            
-            # Extract additional details
-            metrics[year]['Details'] = {
-                'COGS': self.clean_number(df[df.iloc[:, 0].str.contains('Cost of Goods Sold', na=False)].iloc[0][year]),
-                'Gross_Profit': self.clean_number(df[df.iloc[:, 0].str.contains('Gross Profit', na=False)].iloc[0][year]),
-                'Operating_Expenses': self.clean_number(total_expenses),
-                'EBIT': self.clean_number(df[df.iloc[:, 0].str.contains('Earnings Before Interest & Taxes', na=False)].iloc[0][year]),
-                'Interest_Expense': self.clean_number(df[df.iloc[:, 0].str.contains('Interest Expense', na=False)].iloc[0][year]),
-                'Tax_Expense': self.clean_number(df[df.iloc[:, 0].str.contains('Income Taxes', na=False)].iloc[0][year])
-            }
-            
-        return metrics
-
-    def process_balance_sheet(self, df: pd.DataFrame) -> Dict:
-        """Process balance sheet data"""
-        metrics = {}
-        years = [col for col in df.columns if str(col).isdigit()]
+        # Get year columns
+        year_cols = [col for col in df.columns if str(col).isdigit()]
         
-        for year in years:
-            metrics[year] = {
-                'Assets': 0,
-                'Liabilities': 0,
-                'Equity': 0,
-                'Details': {}
-            }
+        if not year_cols:
+            raise ValueError("No year columns found in data")
             
-            # Extract main metrics
-            metrics[year]['Assets'] = self.clean_number(df[df.iloc[:, 0].str.contains('Total Assets', na=False)].iloc[0][year])
-            metrics[year]['Liabilities'] = self.clean_number(df[df.iloc[:, 0].str.contains('Total Liabilities', na=False)].iloc[0][year])
-            metrics[year]['Equity'] = self.clean_number(df[df.iloc[:, 0].str.contains("Shareholder's Equity", na=False)].iloc[-1][year])
+        # Clean numeric data
+        for col in year_cols:
+            df[col] = df[col].apply(self.clean_number)
             
-            # Extract additional details
-            metrics[year]['Details'] = {
-                'Current_Assets': self.clean_number(df[df.iloc[:, 0].str.contains('Total current assets', na=False)].iloc[0][year]),
-                'Fixed_Assets': self.clean_number(df[df.iloc[:, 0].str.contains('Property & Equipment', na=False)].iloc[0][year]),
-                'Current_Liabilities': self.clean_number(df[df.iloc[:, 0].str.contains('Total current liabilities', na=False)].iloc[0][year]),
-                'Long_Term_Debt': self.clean_number(df[df.iloc[:, 0].str.contains('Long-term debt', na=False)].iloc[0][year]),
-                'Retained_Earnings': self.clean_number(df[df.iloc[:, 0].str.contains('Retained Earnings', na=False)].iloc[0][year])
-            }
-            
-        return metrics
+        return df, year_cols
 
 class FinancialAnalyzer:
-    """Enhanced Financial Analyzer using small models"""
+    """Financial analysis using small models"""
     
     def __init__(self):
         self.extractor = FinancialDataExtractor()
@@ -140,185 +95,135 @@ class FinancialAnalyzer:
             logger.error(f"Error loading models: {str(e)}")
             raise
 
-    def calculate_financial_ratios(self, income_metrics: Dict, balance_metrics: Dict, year: str) -> Dict:
-        """Calculate key financial ratios"""
-        try:
-            income = income_metrics[year]
-            balance = balance_metrics[year]
+    def calculate_metrics(self, income_df: pd.DataFrame, balance_df: pd.DataFrame, year_cols: list) -> dict:
+        """Calculate financial metrics"""
+        metrics = {}
+        
+        for year in year_cols:
+            # Income Statement metrics
+            income = {
+                'Revenue': income_df[income_df['Period'].str.contains('Total Net Revenue|Revenue', na=False, case=False)][year].iloc[0],
+                'COGS': income_df[income_df['Period'].str.contains('Cost of Goods Sold', na=False, case=False)][year].iloc[0],
+                'Operating_Expenses': income_df[income_df['Period'].str.contains('Total Expenses', na=False, case=False)][year].iloc[0],
+                'EBIT': income_df[income_df['Period'].str.contains('Earnings Before Interest & Taxes', na=False, case=False)][year].iloc[0],
+                'Net_Income': income_df[income_df['Period'].str.contains('Net Income|Net Earnings', na=False, case=False)][year].iloc[-1]
+            }
             
-            ratios = {
+            # Balance Sheet metrics
+            balance = {
+                'Total_Assets': balance_df[balance_df['Period'].str.contains('Total Assets', na=False, case=False)][year].iloc[0],
+                'Current_Assets': balance_df[balance_df['Period'].str.contains('Total current assets', na=False, case=False)][year].iloc[0],
+                'Total_Liabilities': balance_df[balance_df['Period'].str.contains('Total Liabilities', na=False, case=False)][year].iloc[0],
+                'Current_Liabilities': balance_df[balance_df['Period'].str.contains('Total current liabilities', na=False, case=False)][year].iloc[0],
+                'Equity': balance_df[balance_df['Period'].str.contains("Shareholder's Equity", na=False, case=False)][year].iloc[-1]
+            }
+            
+            # Calculate ratios
+            metrics[year] = {
                 'Profitability': {
-                    'Gross_Margin': (income['Details']['Gross_Profit'] / income['Revenue']) * 100,
-                    'Operating_Margin': (income['Details']['EBIT'] / income['Revenue']) * 100,
-                    'Net_Margin': (income['Profit'] / income['Revenue']) * 100
+                    'Gross_Margin': ((income['Revenue'] - income['COGS']) / income['Revenue']) * 100,
+                    'Operating_Margin': (income['EBIT'] / income['Revenue']) * 100,
+                    'Net_Margin': (income['Net_Income'] / income['Revenue']) * 100,
+                    'ROE': (income['Net_Income'] / balance['Equity']) * 100,
+                    'ROA': (income['Net_Income'] / balance['Total_Assets']) * 100
                 },
                 'Liquidity': {
-                    'Current_Ratio': balance['Details']['Current_Assets'] / balance['Details']['Current_Liabilities'],
-                    'Quick_Ratio': (balance['Details']['Current_Assets'] - 0) / balance['Details']['Current_Liabilities'],
-                    'Cash_Ratio': 0  # Would need cash balance for this
+                    'Current_Ratio': balance['Current_Assets'] / balance['Current_Liabilities'],
+                    'Working_Capital': balance['Current_Assets'] - balance['Current_Liabilities']
                 },
-                'Solvency': {
-                    'Debt_to_Equity': balance['Liabilities'] / balance['Equity'],
-                    'Debt_Ratio': balance['Liabilities'] / balance['Assets'],
-                    'Interest_Coverage': income['Details']['EBIT'] / income['Details']['Interest_Expense'] if income['Details']['Interest_Expense'] != 0 else float('inf')
-                },
-                'Efficiency': {
-                    'Asset_Turnover': income['Revenue'] / balance['Assets'],
-                    'ROE': income['Profit'] / balance['Equity'] * 100,
-                    'ROA': income['Profit'] / balance['Assets'] * 100
+                'Growth': {
+                    'Revenue': income['Revenue'],
+                    'Net_Income': income['Net_Income'],
+                    'Total_Assets': balance['Total_Assets']
                 }
             }
-            
-            return ratios
-            
-        except Exception as e:
-            logger.error(f"Error calculating ratios: {str(e)}")
-            return {}
-
-    def generate_analysis_prompt(self, income_metrics: Dict, balance_metrics: Dict, ratios: Dict) -> str:
-        """Generate analysis prompt for LLM"""
-        latest_year = max(income_metrics.keys())
-        earliest_year = min(income_metrics.keys())
         
-        # Calculate growth metrics
-        revenue_growth = ((income_metrics[latest_year]['Revenue'] - income_metrics[earliest_year]['Revenue']) 
-                         / income_metrics[earliest_year]['Revenue'] * 100)
-        profit_growth = ((income_metrics[latest_year]['Profit'] - income_metrics[earliest_year]['Profit']) 
-                        / income_metrics[earliest_year]['Profit'] * 100)
-        asset_growth = ((balance_metrics[latest_year]['Assets'] - balance_metrics[earliest_year]['Assets']) 
-                       / balance_metrics[earliest_year]['Assets'] * 100)
-
-        prompt = f"""[INST] As a financial analyst, provide a comprehensive analysis of this company:
-
-Financial Performance ({earliest_year}-{latest_year}):
-1. Growth Metrics:
-   - Revenue Growth: {revenue_growth:.1f}%
-   - Profit Growth: {profit_growth:.1f}%
-   - Asset Growth: {asset_growth:.1f}%
-
-2. Latest Year Performance ({latest_year}):
-   - Revenue: ${income_metrics[latest_year]['Revenue']:,.0f}
-   - Net Profit: ${income_metrics[latest_year]['Profit']:,.0f}
-   - Total Assets: ${balance_metrics[latest_year]['Assets']:,.0f}
-
-3. Key Ratios ({latest_year}):
-   - Profitability:
-     * Gross Margin: {ratios['Profitability']['Gross_Margin']:.1f}%
-     * Operating Margin: {ratios['Profitability']['Operating_Margin']:.1f}%
-     * Net Margin: {ratios['Profitability']['Net_Margin']:.1f}%
-   - Financial Health:
-     * Current Ratio: {ratios['Liquidity']['Current_Ratio']:.2f}
-     * Debt-to-Equity: {ratios['Solvency']['Debt_to_Equity']:.2f}
-     * ROE: {ratios['Efficiency']['ROE']:.1f}%
-
-Provide:
-1. Overall financial health assessment
-2. Key performance insights and trends
-3. Risk analysis and concerns
-4. Specific strategic recommendations
-[/INST]"""
-
-        return prompt
+        return metrics
 
     def analyze_financials(self, income_df: pd.DataFrame, balance_df: pd.DataFrame) -> str:
-        """Generate complete financial analysis"""
+        """Generate financial analysis"""
         try:
-            # Extract metrics
-            income_metrics = self.extractor.process_income_statement(income_df)
-            balance_metrics = self.extractor.process_balance_sheet(balance_df)
+            # Extract and clean data
+            income_df, year_cols = self.extractor.extract_data(income_df)
+            balance_df, _ = self.extractor.extract_data(balance_df)
             
-            # Calculate ratios for latest year
-            latest_year = max(income_metrics.keys())
-            ratios = self.calculate_financial_ratios(income_metrics, balance_metrics, latest_year)
+            # Calculate metrics
+            metrics = self.calculate_metrics(income_df, balance_df, year_cols)
             
-            # Generate analysis prompt
-            analysis_prompt = self.generate_analysis_prompt(income_metrics, balance_metrics, ratios)
+            # Get latest and earliest years
+            latest_year = max(year_cols)
+            earliest_year = min(year_cols)
             
-            # Get sentiment analysis
-            sentiment = self.sentiment_model(
-                analysis_prompt[:512],
-                truncation=True
-            )[0]
+            # Calculate growth
+            revenue_growth = ((metrics[latest_year]['Growth']['Revenue'] / metrics[earliest_year]['Growth']['Revenue']) - 1) * 100
+            profit_growth = ((metrics[latest_year]['Growth']['Net_Income'] / metrics[earliest_year]['Growth']['Net_Income']) - 1) * 100
             
-            # Generate analysis
+            # Generate analysis context
+            context = f"""Financial Analysis ({earliest_year}-{latest_year}):
+
+Performance Metrics:
+- Revenue Growth: {revenue_growth:.1f}%
+- Profit Growth: {profit_growth:.1f}%
+- Current Gross Margin: {metrics[latest_year]['Profitability']['Gross_Margin']:.1f}%
+- Current Net Margin: {metrics[latest_year]['Profitability']['Net_Margin']:.1f}%
+- ROE: {metrics[latest_year]['Profitability']['ROE']:.1f}%
+- Current Ratio: {metrics[latest_year]['Liquidity']['Current_Ratio']:.2f}
+
+Trends:
+- Revenue has grown from ${metrics[earliest_year]['Growth']['Revenue']:,.0f} to ${metrics[latest_year]['Growth']['Revenue']:,.0f}
+- Net Income has changed from ${metrics[earliest_year]['Growth']['Net_Income']:,.0f} to ${metrics[latest_year]['Growth']['Net_Income']:,.0f}
+- Profitability margins show {('improving' if metrics[latest_year]['Profitability']['Net_Margin'] > metrics[earliest_year]['Profitability']['Net_Margin'] else 'declining')} trend"""
+
+            # Get sentiment
+            sentiment = self.sentiment_model(context[:512])[0]
+            
+            # Generate detailed analysis
             analysis = self.analysis_model(
-                analysis_prompt,
+                f"[INST] As a financial analyst, provide a detailed analysis of this company:\n\n{context}\n\nInclude:\n1. Financial health assessment\n2. Key performance insights\n3. Strategic recommendations [/INST]",
                 max_length=1500,
+                num_return_sequences=1,
                 do_sample=True,
-                temperature=0.7,
-                num_return_sequences=1
+                temperature=0.7
             )[0]['generated_text']
             
-            # Format the output
-            output = self.format_response(analysis, sentiment, income_metrics, balance_metrics, ratios, latest_year)
-            
-            return output
-            
-        except Exception as e:
-            logger.error(f"Analysis error: {str(e)}")
-            return f"Error in analysis: {str(e)}"
+            # Format output
+            output = f"""# Financial Analysis Report
 
-    def format_response(self, analysis: str, sentiment: Dict, 
-                       income_metrics: Dict, balance_metrics: Dict, 
-                       ratios: Dict, year: str) -> str:
-        """Format the analysis response"""
-        try:
-            # Split analysis into sections
-            sections = analysis.split('\n\n')
-            
-            # Format metrics section
-            metrics_section = f"""
-### Key Financial Metrics ({year})
-- Revenue: ${income_metrics[year]['Revenue']:,.0f}
-- Net Profit: ${income_metrics[year]['Profit']:,.0f}
-- Total Assets: ${balance_metrics[year]['Assets']:,.0f}
+## Overall Sentiment: {sentiment['label'].upper()} ({sentiment['score']:.1%})
 
-### Financial Ratios
-- Profitability:
-  * Gross Margin: {ratios['Profitability']['Gross_Margin']:.1f}%
-  * Operating Margin: {ratios['Profitability']['Operating_Margin']:.1f}%
-  * Net Margin: {ratios['Profitability']['Net_Margin']:.1f}%
-  
-- Financial Health:
-  * Current Ratio: {ratios['Liquidity']['Current_Ratio']:.2f}
-  * Debt-to-Equity: {ratios['Solvency']['Debt_to_Equity']:.2f}
-  * Interest Coverage: {ratios['Solvency']['Interest_Coverage']:.2f}
-  
-- Efficiency:
-  * ROE: {ratios['Efficiency']['ROE']:.1f}%
-  * ROA: {ratios['Efficiency']['ROA']:.1f}%
-  * Asset Turnover: {ratios['Efficiency']['Asset_Turnover']:.2f}
-"""
+## Key Performance Indicators ({latest_year})
+- Gross Margin: {metrics[latest_year]['Profitability']['Gross_Margin']:.1f}%
+- Operating Margin: {metrics[latest_year]['Profitability']['Operating_Margin']:.1f}%
+- Net Margin: {metrics[latest_year]['Profitability']['Net_Margin']:.1f}%
+- ROE: {metrics[latest_year]['Profitability']['ROE']:.1f}%
+- Current Ratio: {metrics[latest_year]['Liquidity']['Current_Ratio']:.2f}
 
-            # Combine all sections
-            output = [
-                "# Financial Analysis Report\n",
-                f"## Overall Sentiment: {sentiment['label'].upper()} ({sentiment['score']:.1%})\n",
-                metrics_section,
-                "\n## Analysis\n",
-                analysis
-            ]
+## Performance Trends ({earliest_year}-{latest_year})
+- Revenue Growth: {revenue_growth:.1f}%
+- Profit Growth: {profit_growth:.1f}%
+- Working Capital: ${metrics[latest_year]['Liquidity']['Working_Capital']:,.0f}
+
+## Analysis
+{analysis}"""
             
-            return "\n".join(output)
+            return output
             
         except Exception as e:
-            logger.error(f"Error formatting response: {str(e)}")
-            return "Error formatting analysis results"
+            logger.error(f"Analysis error: {str(e)}")
+            raise
 
 def analyze_statements(income_statement, balance_sheet):
     """Main function to analyze financial statements"""
     try:
         if not income_statement or not balance_sheet:
             return "Please upload both Income Statement and Balance Sheet CSV files."
-
+            
         # Read files
         income_df = pd.read_csv(income_statement.name)
         balance_df = pd.read_csv(balance_sheet.name)
         
-        # Create analyzer instance
+        # Create analyzer and process
         analyzer = FinancialAnalyzer()
-        
-        # Generate analysis
         result = analyzer.analyze_financials(income_df, balance_df)
         
         # Clear memory
@@ -331,71 +236,33 @@ def analyze_statements(income_statement, balance_sheet):
         return f"""Analysis Error: {str(e)}
         
         Please ensure your CSV files:
-        1. Contain recognizable financial metrics
-        2. Have clear period/year columns
-        3. Use consistent number formatting
-        4. Are not corrupted"""
+        1. Have clear year columns
+        2. Contain recognizable financial metrics
+        3. Use consistent number formatting"""
 
-# Create Gradio interface with compatible parameters
+# Create Gradio interface
 iface = gr.Interface(
     fn=analyze_statements,
     inputs=[
-        gr.File(
-            label="Upload Income Statement (CSV)",
-            file_types=[".csv"],
-            file_count="single"
-        ),
-        gr.File(
-            label="Upload Balance Sheet (CSV)",
-            file_types=[".csv"],
-            file_count="single"
-        )
+        gr.File(label="Upload Income Statement (CSV)", file_types=[".csv"]),
+        gr.File(label="Upload Balance Sheet (CSV)", file_types=[".csv"])
     ],
     outputs=gr.Markdown(),
-    title="Advanced Financial Statement Analyzer",
-    description="""## Professional Financial Analysis Tool
-
-### Supported Financial Statement Formats:
-
-#### Income Statement Requirements:
-- Revenue/Sales information
-- Cost and Expense details
-- Profit/Income figures
-- Operating metrics
-- Period/Year information
-
-#### Balance Sheet Requirements:
-- Asset information (Current & Non-current)
-- Liability details (Current & Long-term)
-- Equity components
-- Period/Year information
-
-### Analysis Output Includes:
-1. Overall Financial Health Assessment
-2. Key Performance Metrics & Ratios
-3. Trend Analysis
-4. Risk Assessment
-5. Strategic Recommendations
+    title="Financial Statement Analyzer",
+    description="""## Financial Analysis Tool
 
-### Usage Instructions:
-1. Upload your Income Statement CSV file
-2. Upload your Balance Sheet CSV file
-3. Wait for the analysis to complete
-4. Review the comprehensive financial analysis report
-""",
-    theme="default"
+Upload your financial statements to get:
+- Performance Analysis
+- Key Metrics & Ratios
+- Trend Analysis
+- Strategic Recommendations""",
+    examples=None
 )
 
-# Launch configurations
+# Launch the interface
 if __name__ == "__main__":
     try:
-        # Configure and launch
-        iface.queue()
-        iface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
-        )
+        iface.launch(server_name="0.0.0.0", server_port=7860)
     except Exception as e:
         logger.error(f"Launch error: {str(e)}")
         sys.exit(1)