Create app.py

app.py

@@ -0,0 +1,471 @@
+import gradio as gr
+import pandas as pd
+import gspread
+from google.oauth2.service_account import Credentials
+import json
+import os
+from datetime import datetime, timedelta
+import plotly.graph_objects as go
+import plotly.express as px
+from io import BytesIO
+
+# Google Sheets Setup
+SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
+
+def get_google_sheets_client():
+    """Initialize Google Sheets client"""
+    try:
+        # Get credentials from environment variable
+        creds_json = os.environ.get('GOOGLE_SHEETS_CREDENTIALS')
+        if not creds_json:
+            raise ValueError("GOOGLE_SHEETS_CREDENTIALS not found in environment")
+        
+        creds_dict = json.loads(creds_json)
+        creds = Credentials.from_service_account_info(creds_dict, scopes=SCOPES)
+        client = gspread.authorize(creds)
+        return client
+    except Exception as e:
+        raise Exception(f"Failed to initialize Google Sheets client: {str(e)}")
+
+def get_sheet():
+    """Get the Google Sheet"""
+    client = get_google_sheets_client()
+    sheet_id = os.environ.get('SHEET_ID')
+    if not sheet_id:
+        raise ValueError("SHEET_ID not found in environment")
+    return client.open_by_key(sheet_id)
+
+def initialize_sheets():
+    """Initialize sheets with headers if empty"""
+    try:
+        spreadsheet = get_sheet()
+        
+        # Initialize Transactions sheet
+        try:
+            trans_sheet = spreadsheet.worksheet("Transactions")
+        except:
+            trans_sheet = spreadsheet.add_worksheet(title="Transactions", rows="1000", cols="10")
+        
+        if not trans_sheet.row_values(1):
+            trans_sheet.update('A1:F1', [['Date', 'Farmer Name', 'Bank Account', 'Amount', 'Type', 'Timestamp']])
+        
+        # Initialize Metadata sheet
+        try:
+            meta_sheet = spreadsheet.worksheet("Metadata")
+        except:
+            meta_sheet = spreadsheet.add_worksheet(title="Metadata", rows="1000", cols="10")
+        
+        if not meta_sheet.row_values(1):
+            meta_sheet.update('A1:B1', [['Type', 'Value']])
+            meta_sheet.update('A2:B2', [['farmer', '']])
+            meta_sheet.update('A3:B3', [['bank', '']])
+        
+        return True
+    except Exception as e:
+        print(f"Error initializing sheets: {str(e)}")
+        return False
+
+def get_farmers():
+    """Get list of registered farmers"""
+    try:
+        spreadsheet = get_sheet()
+        meta_sheet = spreadsheet.worksheet("Metadata")
+        data = meta_sheet.get_all_values()
+        
+        farmers = []
+        for row in data:
+            if len(row) >= 2 and row[0] == 'farmer' and row[1]:
+                farmers.extend([f.strip() for f in row[1].split(',') if f.strip()])
+        
+        return sorted(list(set(farmers)))
+    except Exception as e:
+        print(f"Error getting farmers: {str(e)}")
+        return []
+
+def get_banks():
+    """Get list of registered bank accounts"""
+    try:
+        spreadsheet = get_sheet()
+        meta_sheet = spreadsheet.worksheet("Metadata")
+        data = meta_sheet.get_all_values()
+        
+        banks = []
+        for row in data:
+            if len(row) >= 2 and row[0] == 'bank' and row[1]:
+                banks.extend([b.strip() for b in row[1].split(',') if b.strip()])
+        
+        return sorted(list(set(banks)))
+    except Exception as e:
+        print(f"Error getting banks: {str(e)}")
+        return []
+
+def register_farmer(farmer_name):
+    """Register a new farmer"""
+    try:
+        if not farmer_name or not farmer_name.strip():
+            return "❌ Please enter a farmer name"
+        
+        farmer_name = farmer_name.strip()
+        farmers = get_farmers()
+        
+        if farmer_name in farmers:
+            return f"❌ Farmer '{farmer_name}' is already registered"
+        
+        spreadsheet = get_sheet()
+        meta_sheet = spreadsheet.worksheet("Metadata")
+        data = meta_sheet.get_all_values()
+        
+        # Find the farmer row
+        farmer_row = None
+        for idx, row in enumerate(data):
+            if len(row) >= 1 and row[0] == 'farmer':
+                farmer_row = idx + 1
+                break
+        
+        if farmer_row:
+            current_farmers = data[farmer_row - 1][1] if len(data[farmer_row - 1]) > 1 else ""
+            new_farmers = f"{current_farmers},{farmer_name}" if current_farmers else farmer_name
+            meta_sheet.update_cell(farmer_row, 2, new_farmers)
+        
+        return f"✅ Farmer '{farmer_name}' registered successfully!"
+    except Exception as e:
+        return f"❌ Error registering farmer: {str(e)}"
+
+def register_bank(bank_name):
+    """Register a new bank account"""
+    try:
+        if not bank_name or not bank_name.strip():
+            return "❌ Please enter a bank account name"
+        
+        bank_name = bank_name.strip()
+        banks = get_banks()
+        
+        if bank_name in banks:
+            return f"❌ Bank account '{bank_name}' is already registered"
+        
+        spreadsheet = get_sheet()
+        meta_sheet = spreadsheet.worksheet("Metadata")
+        data = meta_sheet.get_all_values()
+        
+        # Find the bank row
+        bank_row = None
+        for idx, row in enumerate(data):
+            if len(row) >= 1 and row[0] == 'bank':
+                bank_row = idx + 1
+                break
+        
+        if bank_row:
+            current_banks = data[bank_row - 1][1] if len(data[bank_row - 1]) > 1 else ""
+            new_banks = f"{current_banks},{bank_name}" if current_banks else bank_name
+            meta_sheet.update_cell(bank_row, 2, new_banks)
+        
+        return f"✅ Bank account '{bank_name}' registered successfully!"
+    except Exception as e:
+        return f"❌ Error registering bank: {str(e)}"
+
+def add_transaction(date, farmer_name, bank_account, amount, trans_type):
+    """Add a new transaction"""
+    try:
+        if not all([date, farmer_name, bank_account, amount, trans_type]):
+            return "❌ Please fill in all fields"
+        
+        farmer_name = farmer_name.strip()
+        bank_account = bank_account.strip()
+        
+        # Check if farmer exists
+        farmers = get_farmers()
+        if farmer_name not in farmers:
+            return f"❌ Farmer '{farmer_name}' not found. Please register the farmer first or check spelling."
+        
+        # Check if bank exists
+        banks = get_banks()
+        if bank_account not in banks:
+            return f"❌ Bank account '{bank_account}' not found. Please register the bank first."
+        
+        try:
+            amount = float(amount)
+        except:
+            return "❌ Amount must be a valid number"
+        
+        # Format amount based on type
+        if trans_type == "Outgoing (Lent to Farmer)":
+            amount = -abs(amount)
+        else:  # Incoming
+            amount = abs(amount)
+        
+        spreadsheet = get_sheet()
+        trans_sheet = spreadsheet.worksheet("Transactions")
+        
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        trans_sheet.append_row([date, farmer_name, bank_account, amount, trans_type, timestamp])
+        
+        return f"✅ Transaction added successfully! Amount: {amount}"
+    except Exception as e:
+        return f"❌ Error adding transaction: {str(e)}"
+
+def calculate_interest(principal, start_date, end_date):
+    """Calculate 2% monthly interest prorated daily"""
+    try:
+        start = datetime.strptime(start_date, "%Y-%m-%d")
+        end = datetime.strptime(end_date, "%Y-%m-%d")
+        days = (end - start).days
+        
+        # 2% per month = 2/30 = 0.0667% per day
+        daily_rate = 0.02 / 30
+        interest = principal * daily_rate * days
+        return interest
+    except:
+        return 0
+
+def get_farmer_report(farmer_name):
+    """Generate complete report for a farmer with interest calculations"""
+    try:
+        if not farmer_name or not farmer_name.strip():
+            return None, "❌ Please enter a farmer name", None, None, None
+        
+        farmer_name = farmer_name.strip()
+        
+        spreadsheet = get_sheet()
+        trans_sheet = spreadsheet.worksheet("Transactions")
+        data = trans_sheet.get_all_values()
+        
+        if len(data) <= 1:
+            return None, f"❌ No transactions found for farmer '{farmer_name}'", None, None, None
+        
+        # Create DataFrame
+        df = pd.DataFrame(data[1:], columns=data[0])
+        df = df[df['Farmer Name'] == farmer_name]
+        
+        if df.empty:
+            return None, f"❌ No transactions found for farmer '{farmer_name}'", None, None, None
+        
+        df['Amount'] = pd.to_numeric(df['Amount'], errors='coerce')
+        df['Date'] = pd.to_datetime(df['Date'], errors='coerce')
+        df = df.sort_values('Date')
+        
+        # Calculate running balance with interest
+        balance = 0
+        total_lent = 0
+        total_returned = 0
+        last_date = None
+        
+        transactions_with_interest = []
+        
+        for idx, row in df.iterrows():
+            amount = row['Amount']
+            current_date = row['Date'].strftime("%Y-%m-%d")
+            
+            # Calculate interest on outstanding balance since last transaction
+            if balance < 0 and last_date:  # Negative balance means money is owed to us
+                interest = calculate_interest(abs(balance), last_date, current_date)
+                balance -= interest  # Increase what's owed
+                transactions_with_interest.append({
+                    'Date': current_date,
+                    'Description': 'Interest Accrued',
+                    'Bank Account': '-',
+                    'Amount': -interest,
+                    'Balance': balance
+                })
+            
+            # Add transaction
+            balance += amount
+            
+            if amount < 0:  # Outgoing (lent)
+                total_lent += abs(amount)
+            else:  # Incoming (returned)
+                total_returned += amount
+            
+            transactions_with_interest.append({
+                'Date': current_date,
+                'Description': row['Type'],
+                'Bank Account': row['Bank Account'],
+                'Amount': amount,
+                'Balance': balance
+            })
+            
+            last_date = current_date
+        
+        # Calculate interest up to today
+        if balance < 0 and last_date:
+            today = datetime.now().strftime("%Y-%m-%d")
+            interest = calculate_interest(abs(balance), last_date, today)
+            balance -= interest
+            transactions_with_interest.append({
+                'Date': today,
+                'Description': 'Interest Accrued (to today)',
+                'Bank Account': '-',
+                'Amount': -interest,
+                'Balance': balance
+            })
+        
+        # Create detailed transaction DataFrame
+        detailed_df = pd.DataFrame(transactions_with_interest)
+        
+        # Summary statistics
+        remaining_balance = balance
+        
+        summary = f"""
+        📊 **Farmer Report: {farmer_name}**
+        
+        💰 **Total Lent:** ₹{total_lent:,.2f}
+        💵 **Total Returned:** ₹{total_returned:,.2f}
+        📈 **Interest Accrued:** ₹{(abs(remaining_balance) - (total_lent - total_returned)):,.2f}
+        🔢 **Current Balance:** ₹{abs(remaining_balance):,.2f} {'(Farmer owes you)' if remaining_balance < 0 else '(You owe farmer)'}
+        """
+        
+        # Create visualizations
+        # 1. Distribution by bank
+        bank_dist = df.groupby('Bank Account')['Amount'].apply(lambda x: abs(x[x < 0].sum())).reset_index()
+        bank_dist.columns = ['Bank Account', 'Amount Lent']
+        
+        fig_bank = go.Figure(go.Bar(
+            x=bank_dist['Amount Lent'],
+            y=bank_dist['Bank Account'],
+            orientation='h',
+            marker_color='lightblue'
+        ))
+        fig_bank.update_layout(
+            title=f"Money Lent to {farmer_name} by Bank Account",
+            xaxis_title="Amount (₹)",
+            yaxis_title="Bank Account",
+            height=300
+        )
+        
+        # 2. Payment status pie chart
+        paid_pct = (total_returned / total_lent * 100) if total_lent > 0 else 0
+        remaining_pct = 100 - paid_pct
+        
+        fig_pie = go.Figure(data=[go.Pie(
+            labels=['Returned', 'Outstanding (with interest)'],
+            values=[total_returned, abs(remaining_balance)],
+            marker_colors=['lightgreen', 'lightcoral']
+        )])
+        fig_pie.update_layout(
+            title=f"Payment Status for {farmer_name}",
+            height=300
+        )
+        
+        return detailed_df, summary, fig_bank, fig_pie, remaining_balance
+    
+    except Exception as e:
+        return None, f"❌ Error generating report: {str(e)}", None, None, None
+
+# Initialize sheets on startup
+initialize_sheets()
+
+# Gradio Interface
+with gr.Blocks(title="Farmer Ledger Tracker", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🌾 Farmer Ledger Tracker")
+    gr.Markdown("Track loans to farmers with 2% monthly interest (prorated daily)")
+    
+    with gr.Tabs():
+        # Tab 1: Add Transactions
+        with gr.Tab("📝 Add Transaction"):
+            gr.Markdown("### Register New Entities")
+            
+            with gr.Row():
+                with gr.Column():
+                    new_farmer_input = gr.Textbox(label="New Farmer Name", placeholder="Enter farmer name")
+                    register_farmer_btn = gr.Button("Register Farmer", variant="primary")
+                    farmer_status = gr.Textbox(label="Status", interactive=False)
+                
+                with gr.Column():
+                    new_bank_input = gr.Textbox(label="New Bank Account", placeholder="Enter bank name")
+                    register_bank_btn = gr.Button("Register Bank Account", variant="primary")
+                    bank_status = gr.Textbox(label="Status", interactive=False)
+            
+            gr.Markdown("### Add Transaction")
+            
+            with gr.Row():
+                trans_date = gr.Textbox(label="Date (YYYY-MM-DD)", placeholder="2024-01-15")
+                trans_farmer = gr.Dropdown(label="Farmer Name", choices=get_farmers(), allow_custom_value=True)
+            
+            with gr.Row():
+                trans_bank = gr.Dropdown(label="Bank Account", choices=get_banks(), allow_custom_value=True)
+                trans_amount = gr.Number(label="Amount (₹)", value=0)
+            
+            trans_type = gr.Radio(
+                label="Transaction Type",
+                choices=["Outgoing (Lent to Farmer)", "Incoming (Farmer Paid Back)"],
+                value="Outgoing (Lent to Farmer)"
+            )
+            
+            add_trans_btn = gr.Button("Add Transaction", variant="primary", size="lg")
+            trans_status = gr.Textbox(label="Status", interactive=False)
+            
+            # Refresh button for dropdowns
+            refresh_btn = gr.Button("🔄 Refresh Farmer & Bank Lists", size="sm")
+            
+            def refresh_lists():
+                return gr.Dropdown(choices=get_farmers()), gr.Dropdown(choices=get_banks())
+            
+            # Event handlers for Tab 1
+            register_farmer_btn.click(
+                fn=register_farmer,
+                inputs=[new_farmer_input],
+                outputs=[farmer_status]
+            )
+            
+            register_bank_btn.click(
+                fn=register_bank,
+                inputs=[new_bank_input],
+                outputs=[bank_status]
+            )
+            
+            add_trans_btn.click(
+                fn=add_transaction,
+                inputs=[trans_date, trans_farmer, trans_bank, trans_amount, trans_type],
+                outputs=[trans_status]
+            )
+            
+            refresh_btn.click(
+                fn=refresh_lists,
+                outputs=[trans_farmer, trans_bank]
+            )
+        
+        # Tab 2: View Reports
+        with gr.Tab("📊 Farmer Reports"):
+            gr.Markdown("### Generate Farmer Report")
+            
+            report_farmer = gr.Dropdown(
+                label="Select Farmer",
+                choices=get_farmers(),
+                allow_custom_value=True
+            )
+            
+            generate_report_btn = gr.Button("Generate Report", variant="primary", size="lg")
+            
+            report_summary = gr.Markdown()
+            
+            with gr.Row():
+                bank_chart = gr.Plot(label="Distribution by Bank Account")
+                pie_chart = gr.Plot(label="Payment Status")
+            
+            report_df = gr.Dataframe(
+                label="Transaction History (with Interest Calculations)",
+                interactive=False,
+                wrap=True
+            )
+            
+            download_note = gr.Markdown("💡 **Tip:** You can copy the table data or take a screenshot to save as PDF")
+            
+            # Refresh farmer list in reports tab
+            refresh_report_btn = gr.Button("🔄 Refresh Farmer List", size="sm")
+            
+            def refresh_report_list():
+                return gr.Dropdown(choices=get_farmers())
+            
+            # Event handlers for Tab 2
+            generate_report_btn.click(
+                fn=get_farmer_report,
+                inputs=[report_farmer],
+                outputs=[report_df, report_summary, bank_chart, pie_chart, gr.State()]
+            )
+            
+            refresh_report_btn.click(
+                fn=refresh_report_list,
+                outputs=[report_farmer]
+            )
+
+if __name__ == "__main__":
+    app.launch()