Update app.py

app.py

@@ -3,8 +3,10 @@ import gradio as gr
 import pandas as pd
 import torch
 import logging
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
 import gc
+import re
+from transformers import pipeline
+from typing import Dict, List, Tuple, Optional
 
 # Setup logging
 logging.basicConfig(
@@ -17,38 +19,100 @@ 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()
-
-def validate_financial_csv(file_obj, file_type):
-    """Validate financial CSV files"""
-    try:
-        df = pd.read_csv(file_obj)
-        
-        # Expected columns based on file type
-        expected_columns = {
-            'income_statement': ['Revenue', 'Expenses', 'Profit'],
-            'balance_sheet': ['Assets', 'Liabilities', 'Equity']
-        }
+class FinancialDataExtractor:
+    """Extracts and processes financial data from raw CSV files"""
+    
+    def __init__(self):
+        self.numeric_pattern = re.compile(r'[^\d.-]+')
         
-        # Check for minimum required columns
-        found_columns = set(df.columns)
-        required_columns = set(expected_columns.get(file_type, []))
+    def clean_number(self, value: str) -> float:
+        """Clean numeric values from financial statements"""
+        try:
+            if pd.isna(value) or value == '' or value == '-':
+                return 0.0
+            if isinstance(value, (int, float)):
+                return float(value)
+            
+            # Remove currency symbols, spaces, commas
+            cleaned = str(value).replace('$', '').replace(',', '').strip()
+            # Handle parentheses for negative numbers
+            if '(' in cleaned and ')' in cleaned:
+                cleaned = '-' + cleaned.replace('(', '').replace(')', '')
+            return float(cleaned)
+        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()]
         
-        if not any(col in found_columns for col in required_columns):
-            return False, f"Missing required columns. Expected at least one of: {required_columns}"
+        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()]
         
-        return True, "Valid CSV file"
-    except Exception as e:
-        return False, f"Invalid CSV file: {str(e)}"
+        for year in years:
+            metrics[year] = {
+                'Assets': 0,
+                'Liabilities': 0,
+                'Equity': 0,
+                'Details': {}
+            }
+            
+            # 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])
+            
+            # 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
 
 class FinancialAnalyzer:
-    """Simplified Financial Analyzer using small models"""
+    """Enhanced Financial Analyzer using small models"""
     
     def __init__(self):
+        self.extractor = FinancialDataExtractor()
         self.sentiment_model = None
         self.analysis_model = None
         self.load_models()
@@ -64,7 +128,7 @@ class FinancialAnalyzer:
                 truncation=True
             )
             
-            # Load small model for analysis and recommendations
+            # Load small model for analysis
             self.analysis_model = pipeline(
                 "text-generation",
                 model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
@@ -76,173 +140,166 @@ class FinancialAnalyzer:
             logger.error(f"Error loading models: {str(e)}")
             raise
 
-    def process_csv(self, file_obj):
-        """Process CSV file and extract KPIs"""
+    def calculate_financial_ratios(self, income_metrics: Dict, balance_metrics: Dict, year: str) -> Dict:
+        """Calculate key financial ratios"""
         try:
-            if file_obj is None:
-                raise ValueError("No file provided")
-            
-            # Read CSV with better column handling
-            df = pd.read_csv(file_obj, skipinitialspace=True)
+            income = income_metrics[year]
+            balance = balance_metrics[year]
             
-            if df.empty:
-                raise ValueError("Empty CSV file")
-
-            # Clean column names
-            df.columns = df.columns.str.strip()
-            
-            # Log the columns found
-            logger.info(f"Found columns: {df.columns.tolist()}")
-            
-            # Remove any unnamed columns
-            df = df.loc[:, ~df.columns.str.contains('^Unnamed')]
-            
-            # Convert columns to numeric where possible
-            for col in df.columns:
-                df[col] = pd.to_numeric(df[col].str.replace('[$,()]', '', regex=True), errors='ignore')
-            
-            # Get numeric columns
-            numeric_cols = df.select_dtypes(include=['float64', 'int64']).columns
-            if len(numeric_cols) == 0:
-                raise ValueError("No numeric columns found in CSV")
-            
-            logger.info(f"Numeric columns: {numeric_cols.tolist()}")
-            
-            # Calculate meaningful KPIs
-            kpis = {
-                'total_revenue': df[numeric_cols].sum().sum(),
-                'average_values': df[numeric_cols].mean(),
-                'year_over_year_growth': df[numeric_cols].pct_change().mean() * 100,
-                'key_metrics': df[numeric_cols].describe()
+            ratios = {
+                '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
+                },
+                '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
+                },
+                '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
+                }
             }
             
-            return df[numeric_cols].describe(), kpis
+            return ratios
             
         except Exception as e:
-            logger.error(f"Error processing CSV: {str(e)}")
-            raise
-
-    def analyze_financials(self, income_summary, balance_summary):
-        """Generate financial analysis and recommendations"""
-        try:
-            # Extract meaningful metrics
-            income_metrics = {
-                'Total Revenue': income_summary[1]['total_revenue'],
-                'Average Values': income_summary[1]['average_values'].mean(),
-                'Growth Rate': income_summary[1]['year_over_year_growth'].mean()
-            }
-            
-            balance_metrics = {
-                'Total Assets': balance_summary[1]['total_revenue'],
-                'Average Values': balance_summary[1]['average_values'].mean(),
-                'Growth Rate': balance_summary[1]['year_over_year_growth'].mean()
-            }
+            logger.error(f"Error calculating ratios: {str(e)}")
+            return {}
 
-            financial_context = f"""
-            Income Statement Analysis:
-            - Total Revenue: ${income_metrics['Total Revenue']:,.2f}
-            - Average Revenue: ${income_metrics['Average Values']:,.2f}
-            - Growth Rate: {income_metrics['Growth Rate']:.2f}%
-            
-            Detailed Income Metrics:
-            {income_summary[0].to_string()}
-            
-            Balance Sheet Analysis:
-            - Total Assets: ${balance_metrics['Total Assets']:,.2f}
-            - Average Assets: ${balance_metrics['Average Values']:,.2f}
-            - Growth Rate: {balance_metrics['Growth Rate']:.2f}%
-            
-            Detailed Balance Metrics:
-            {balance_summary[0].to_string()}
-            """
-
-            # Generate sentiment analysis
-            sentiment = self.sentiment_model(
-                financial_context, 
-                truncation=True, 
-                max_length=512
-            )[0]
-            
-            # Generate business analysis
-            analysis_prompt = f"""[INST] As a financial analyst, provide a detailed analysis based on these financial metrics:
-
-            {financial_context}
+    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)
 
-            Sentiment: {sentiment['label']} ({sentiment['score']:.2%})
+        prompt = f"""[INST] As a financial analyst, provide a comprehensive analysis of this company:
 
-            Please provide:
+Financial Performance ({earliest_year}-{latest_year}):
+1. Growth Metrics:
+   - Revenue Growth: {revenue_growth:.1f}%
+   - Profit Growth: {profit_growth:.1f}%
+   - Asset Growth: {asset_growth:.1f}%
 
-            1. Business Status:
-            - Financial health assessment
-            - Growth trajectory
-            - Key performance indicators analysis
+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}
 
-            2. Key Insights:
-            - Revenue trends
-            - Asset utilization
-            - Financial efficiency metrics
-            - Areas of concern or opportunity
+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}%
 
-            3. Strategic Recommendations:
-            - Specific action items based on the metrics
-            - Growth opportunities
-            - Risk mitigation strategies
-            - Timeline-based roadmap
+Provide:
+1. Overall financial health assessment
+2. Key performance insights and trends
+3. Risk analysis and concerns
+4. Specific strategic recommendations
+[/INST]"""
 
-            Be specific and data-driven in your analysis.
-            [/INST]"""
+        return prompt
 
-            response = self.analysis_model(
+    def analyze_financials(self, income_df: pd.DataFrame, balance_df: pd.DataFrame) -> str:
+        """Generate complete financial analysis"""
+        try:
+            # Extract metrics
+            income_metrics = self.extractor.process_income_statement(income_df)
+            balance_metrics = self.extractor.process_balance_sheet(balance_df)
+            
+            # Calculate ratios for latest year
+            latest_year = max(income_metrics.keys())
+            ratios = self.calculate_financial_ratios(income_metrics, balance_metrics, latest_year)
+            
+            # Generate analysis prompt
+            analysis_prompt = self.generate_analysis_prompt(income_metrics, balance_metrics, ratios)
+            
+            # Get sentiment analysis
+            sentiment = self.sentiment_model(
+                analysis_prompt[:512],
+                truncation=True
+            )[0]
+            
+            # Generate analysis
+            analysis = self.analysis_model(
                 analysis_prompt,
                 max_length=1500,
-                do_sample=False,
-                num_return_sequences=1,
-                truncation=True,
-                pad_token_id=self.analysis_model.tokenizer.eos_token_id
-            )
-
-            return self.format_response(response[0]['generated_text'], sentiment)
-
+                do_sample=True,
+                temperature=0.7,
+                num_return_sequences=1
+            )[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"Error in analysis: {str(e)}")
-            return f"Error generating analysis: {str(e)}"
+            logger.error(f"Analysis error: {str(e)}")
+            return f"Error in analysis: {str(e)}"
 
-    def format_response(self, analysis_text, sentiment):
-        """Format the analysis response into structured sections"""
+    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 the analysis into sections
-            sections = analysis_text.split('\n\n')
-            
-            # Initialize output sections
-            status = []
-            insights = []
-            recommendations = []
-            
-            # Process each section
-            current_section = None
-            for section in sections:
-                if "Business Status" in section:
-                    current_section = status
-                elif "Key Insights" in section:
-                    current_section = insights
-                elif "Strategic Recommendations" in section:
-                    current_section = recommendations
-                elif current_section is not None:
-                    current_section.append(section.strip())
+            # Split analysis into sections
+            sections = analysis.split('\n\n')
             
-            # Format the final output
+            # 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}
+
+### 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}
+"""
+
+            # Combine all sections
             output = [
-                "# Financial Analysis Report\n\n",
-                f"## Overall Sentiment: {sentiment['label'].upper()} ({sentiment['score']:.2%})\n\n",
-                "## Business Status\n",
-                "".join(f"- {item}\n" for item in status if item),
-                "\n## Key Business Insights\n",
-                "".join(f"- {item}\n" for item in insights if item),
-                "\n## Strategic Recommendations & Roadmap\n",
-                "".join(f"- {item}\n" for item in recommendations if item)
+                "# Financial Analysis Report\n",
+                f"## Overall Sentiment: {sentiment['label'].upper()} ({sentiment['score']:.1%})\n",
+                metrics_section,
+                "\n## Analysis\n",
+                analysis
             ]
             
-            return "".join(output)
+            return "\n".join(output)
             
         except Exception as e:
             logger.error(f"Error formatting response: {str(e)}")
@@ -254,22 +311,19 @@ def analyze_statements(income_statement, balance_sheet):
         if not income_statement or not balance_sheet:
             return "Please upload both Income Statement and Balance Sheet CSV files."
 
-        # Validate files
-        income_valid, income_msg = validate_financial_csv(income_statement, 'income_statement')
-        if not income_valid:
-            return f"Invalid Income Statement: {income_msg}"
-            
-        balance_valid, balance_msg = validate_financial_csv(balance_sheet, 'balance_sheet')
-        if not balance_valid:
-            return f"Invalid Balance Sheet: {balance_msg}"
-
-        # Process if valid
+        # Read files
+        income_df = pd.read_csv(income_statement.name)
+        balance_df = pd.read_csv(balance_sheet.name)
+        
+        # Create analyzer instance
         analyzer = FinancialAnalyzer()
-        income_summary = analyzer.process_csv(income_statement)
-        balance_summary = analyzer.process_csv(balance_sheet)
         
-        result = analyzer.analyze_financials(income_summary, balance_summary)
+        # Generate analysis
+        result = analyzer.analyze_financials(income_df, balance_df)
+        
+        # Clear memory
         clear_gpu_memory()
+        
         return result
         
     except Exception as e:
@@ -277,58 +331,167 @@ def analyze_statements(income_statement, balance_sheet):
         return f"""Analysis Error: {str(e)}
         
         Please ensure your CSV files:
-        1. Have proper headers (Revenue, Expenses, Profit for Income Statement)
-        2. Contain numeric data
-        3. Follow standard financial statement format
+        1. Contain recognizable financial metrics
+        2. Have clear period/year columns
+        3. Use consistent number formatting
         4. Are not corrupted"""
 
-# Create Gradio interface
+# Create Gradio interface with enhanced features
 iface = gr.Interface(
     fn=analyze_statements,
     inputs=[
         gr.File(
             label="Upload Income Statement (CSV)",
             file_types=[".csv"],
-            file_count="single"
+            file_count="single",
+            info="Upload your income statement in CSV format"
         ),
         gr.File(
             label="Upload Balance Sheet (CSV)",
             file_types=[".csv"],
-            file_count="single"
+            file_count="single",
+            info="Upload your balance sheet in CSV format"
+        )
+    ],
+    outputs=[
+        gr.Markdown(
+            label="Financial Analysis Report",
+            show_label=True
         )
     ],
-    outputs=gr.Markdown(),
-    title="Financial Statement Analyzer",
-    description="""## Financial Analysis Tool
-
-How to use:
-1. Prepare your CSV files with proper headers:
-   - Income Statement: Revenue, Expenses, Profit
-   - Balance Sheet: Assets, Liabilities, Equity
-2. Upload both files using the buttons below
-3. Wait for the analysis to complete
-
-The tool will provide:
-- Business Status Assessment
-- Key Financial Insights
-- Strategic Recommendations
-
-Requirements:
-- Files must be in CSV format
-- Must contain numeric data
-- Standard financial statement format required""",
-    flagging_mode="never"
+    title="Advanced Financial Statement Analyzer",
+    description="""## Professional Financial Analysis Tool
+
+### Key Features:
+- Comprehensive financial analysis using AI
+- Sentiment analysis of financial performance
+- Key ratio calculations and trend analysis
+- Strategic recommendations
+
+### Supported Financial Statement Formats:
+
+#### Income Statement should include:
+- Revenue/Sales information
+- Cost and Expense details
+- Profit/Income figures
+- Operating metrics
+- Period/Year information
+
+#### Balance Sheet should include:
+- Asset information (Current & Non-current)
+- Liability details (Current & Long-term)
+- Equity components
+- Period/Year information
+
+### Analysis Output:
+1. Overall Financial Health Assessment
+2. Key Performance Metrics & Ratios
+3. Trend Analysis
+4. Risk Assessment
+5. Strategic Recommendations
+""",
+    article="""### Usage Tips:
+1. Ensure your CSV files are properly formatted
+2. Data should be in chronological order
+3. Numbers can include commas and currency symbols
+4. Negative numbers can be in parentheses
+5. Common headers will be automatically recognized
+
+### About the Analysis:
+- Uses FinBERT for sentiment analysis
+- Employs TinyLLama for strategic insights
+- Calculates over 15 financial ratios
+- Provides actionable recommendations
+""",
+    examples=[
+        ["sample_income_statement.csv", "sample_balance_sheet.csv"]
+    ],
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="purple",
+    ),
+    css="""
+        .gradio-container {
+            font-family: 'IBM Plex Sans', sans-serif;
+        }
+        .gr-button {
+            color: white;
+            border-radius: 8px;
+            background: linear-gradient(45deg, #1f6feb, #4688f1);
+        }
+        .gr-button:hover {
+            background: linear-gradient(45deg, #1856c5, #3b78e7);
+        }
+        .gr-form {
+            border-radius: 12px;
+            background: white;
+            padding: 24px;
+            box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+        }
+        .gr-box {
+            border-radius: 8px;
+        }
+    """
 )
 
-# Launch the interface
-if __name__ == "__main__":
+# Add custom error handling
+def custom_error_handler(err):
+    logger.error(f"Application error: {str(err)}")
+    return """### Error in Analysis
+
+An error occurred while processing your financial statements. Please check:
+1. File format is correct CSV
+2. Contains required financial metrics
+3. Data is properly formatted
+4. No corrupted or missing values
+
+If the problem persists, try:
+- Removing any special formatting
+- Ensuring consistent date/period format
+- Checking for missing required fields
+
+Error details: {str(err)}
+"""
+
+iface.error_handler = custom_error_handler
+
+# Launch configurations
+def main():
     try:
-        iface.queue()
+        # Setup memory management
+        gc.enable()
+        
+        # Configure Gradio
+        gr.close_all()
+        
+        # Launch with custom configurations
+        iface.queue(concurrency_count=1)
         iface.launch(
-            share=False,
             server_name="0.0.0.0",
-            server_port=7860
+            server_port=7860,
+            share=False,
+            enable_queue=True,
+            max_threads=4,
+            auth=None,  # Add authentication if needed
+            ssl_keyfile=None,  # Add SSL if needed
+            ssl_certfile=None,
+            ssl_keyfile_password=None,
+            show_error=True,
+            show_tips=True,
+            analytics_enabled=False,
+            debug=False
         )
+        
     except Exception as e:
         logger.error(f"Launch error: {str(e)}")
-        sys.exit(1)
+        raise
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        logger.info("Shutting down gracefully...")
+        gr.close_all()
+    except Exception as e:
+        logger.error(f"Fatal error: {str(e)}")
+        sys.exit(1)