Update app.py

app.py

@@ -2,105 +2,118 @@ import streamlit as st
 import pandas as pd
 from docx import Document
 
-# Function to load data from CSV, Excel, or DOCX
+# Function to load financial data
 def load_data(file):
     try:
-        if file.type == "text/csv":
-            return pd.read_csv(file)
-        elif file.type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
-            return pd.read_excel(file)
-        elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-            doc = Document(file)
-            data = [para.text for para in doc.paragraphs if para.text.strip()]  # Remove empty lines
-            return pd.DataFrame(data, columns=["Text"])
-        else:
-            st.error("Unsupported file format. Please upload a CSV, Excel, or DOCX file.")
-            return None
+        df = pd.read_csv(file) if file.type == "text/csv" else pd.read_excel(file)
+        return df
     except Exception as e:
         st.error(f"Error loading file: {e}")
         return None
 
-# Function to generate general journal entries
-def generate_general_entries(data):
-    st.subheader("General Journal Entries")
-    if data.empty:
-        st.error("No data available for journal entries.")
-        return
-    st.write(data)
-
-# Function to generate ledger
-def generate_ledger(data):
-    st.subheader("Ledger")
-    required_columns = {"Account", "Amount"}
-    if required_columns.issubset(data.columns):
-        ledger = data.groupby("Account")["Amount"].sum().reset_index()
-        st.write(ledger)
-    else:
-        st.error(f"Missing columns for ledger: {required_columns - set(data.columns)}")
-
-# Function to generate income statement
-def generate_income_statement(data):
-    st.subheader("Income Statement")
-    required_columns = {"Revenue", "Expenses"}
-    if required_columns.issubset(data.columns):
-        total_revenue = data["Revenue"].sum()
-        total_expenses = data["Expenses"].sum()
-        net_income = total_revenue - total_expenses
-        st.write(f"**Total Revenue:** ${total_revenue:,.2f}")
-        st.write(f"**Total Expenses:** ${total_expenses:,.2f}")
-        st.write(f"**Net Income:** ${net_income:,.2f}")
-    else:
-        st.error(f"Missing columns for income statement: {required_columns - set(data.columns)}")
-
-# Function to generate cash flow statement
-def generate_cash_flow(data):
-    st.subheader("Cash Flow Statement")
-    required_columns = {"Cash Inflow", "Cash Outflow"}
-    if required_columns.issubset(data.columns):
-        total_inflow = data["Cash Inflow"].sum()
-        total_outflow = data["Cash Outflow"].sum()
-        net_cash_flow = total_inflow - total_outflow
-        st.write(f"**Total Cash Inflow:** ${total_inflow:,.2f}")
-        st.write(f"**Total Cash Outflow:** ${total_outflow:,.2f}")
-        st.write(f"**Net Cash Flow:** ${net_cash_flow:,.2f}")
-    else:
-        st.error(f"Missing columns for cash flow statement: {required_columns - set(data.columns)}")
-
-# Function to generate balance sheet
-def generate_balance_sheet(data):
-    st.subheader("Balance Sheet")
-    required_columns = {"Assets", "Liabilities", "Equity"}
-    if required_columns.issubset(data.columns):
-        total_assets = data["Assets"].sum()
-        total_liabilities = data["Liabilities"].sum()
-        total_equity = data["Equity"].sum()
-        st.write(f"**Total Assets:** ${total_assets:,.2f}")
-        st.write(f"**Total Liabilities:** ${total_liabilities:,.2f}")
-        st.write(f"**Total Equity:** ${total_equity:,.2f}")
+# Function to generate journal entries automatically
+def generate_journal_entries(data):
+    st.subheader("📘 Generated Journal Entries")
+
+    journal_entries = []
+    
+    for index, row in data.iterrows():
+        description = row.get("Description", "Unknown Transaction").lower()
+        amount = row.get("Amount", 0)
+        
+        if "sale" in description or "revenue" in description:
+            journal_entries.append({"Date": row.get("Date"), "Account": "Cash", "Debit": amount, "Credit": 0})
+            journal_entries.append({"Date": row.get("Date"), "Account": "Sales Revenue", "Debit": 0, "Credit": amount})
+        
+        elif "expense" in description or "cost" in description:
+            journal_entries.append({"Date": row.get("Date"), "Account": description.capitalize(), "Debit": amount, "Credit": 0})
+            journal_entries.append({"Date": row.get("Date"), "Account": "Cash", "Debit": 0, "Credit": amount})
+
+        elif "purchase" in description or "inventory" in description:
+            journal_entries.append({"Date": row.get("Date"), "Account": "Inventory", "Debit": amount, "Credit": 0})
+            journal_entries.append({"Date": row.get("Date"), "Account": "Cash", "Debit": 0, "Credit": amount})
+
+        elif "loan" in description or "debt" in description:
+            journal_entries.append({"Date": row.get("Date"), "Account": "Cash", "Debit": amount, "Credit": 0})
+            journal_entries.append({"Date": row.get("Date"), "Account": "Loan Payable", "Debit": 0, "Credit": amount})
+
+        elif "investment" in description:
+            journal_entries.append({"Date": row.get("Date"), "Account": "Cash", "Debit": amount, "Credit": 0})
+            journal_entries.append({"Date": row.get("Date"), "Account": "Owner's Equity", "Debit": 0, "Credit": amount})
+
+    journal_df = pd.DataFrame(journal_entries)
+    st.write(journal_df)
+    return journal_df
+
+# Function to generate Ledger
+def generate_ledger(journal_df):
+    st.subheader("📙 Ledger")
+    ledger = journal_df.groupby("Account")[["Debit", "Credit"]].sum().reset_index()
+    ledger["Balance"] = ledger["Debit"] - ledger["Credit"]
+    st.write(ledger)
+    return ledger
+
+# Function to generate Income Statement
+def generate_income_statement(journal_df):
+    st.subheader("📊 Income Statement")
+    revenue = journal_df[journal_df["Account"] == "Sales Revenue"]["Credit"].sum()
+    expenses = journal_df[journal_df["Account"].str.contains("Expense|Cost", case=False, na=False)]["Debit"].sum()
+    net_income = revenue - expenses
+
+    st.write(f"**Total Revenue:** ${revenue:,.2f}")
+    st.write(f"**Total Expenses:** ${expenses:,.2f}")
+    st.write(f"**Net Income:** ${net_income:,.2f}")
+
+    return net_income
+
+# Function to generate Cash Flow Statement
+def generate_cash_flow(journal_df):
+    st.subheader("💰 Cash Flow Statement")
+    cash_inflow = journal_df[journal_df["Account"] == "Cash"]["Debit"].sum()
+    cash_outflow = journal_df[journal_df["Account"] == "Cash"]["Credit"].sum()
+    net_cash_flow = cash_inflow - cash_outflow
+
+    st.write(f"**Total Cash Inflow:** ${cash_inflow:,.2f}")
+    st.write(f"**Total Cash Outflow:** ${cash_outflow:,.2f}")
+    st.write(f"**Net Cash Flow:** ${net_cash_flow:,.2f}")
+
+    return net_cash_flow
+
+# Function to generate Balance Sheet
+def generate_balance_sheet(journal_df, net_income):
+    st.subheader("📜 Balance Sheet")
+
+    assets = journal_df[journal_df["Account"].str.contains("Cash|Inventory", case=False, na=False)]["Debit"].sum()
+    liabilities = journal_df[journal_df["Account"].str.contains("Payable|Loan", case=False, na=False)]["Credit"].sum()
+    equity = journal_df[journal_df["Account"] == "Owner's Equity"]["Credit"].sum() + net_income
+
+    st.write(f"**Total Assets:** ${assets:,.2f}")
+    st.write(f"**Total Liabilities:** ${liabilities:,.2f}")
+    st.write(f"**Total Equity:** ${equity:,.2f}")
+
+    if abs(assets - (liabilities + equity)) < 0.01:
+        st.success("✅ The Balance Sheet is balanced!")
     else:
-        st.error(f"Missing columns for balance sheet: {required_columns - set(data.columns)}")
+        st.warning("⚠️ The Balance Sheet is not balanced!")
 
 # Streamlit App
-st.title("📊 Financial Statement Generator")
+st.title("📑 Automated Financial Statement Generator")
 
-# File upload
-uploaded_file = st.file_uploader("Upload a CSV, Excel, or DOCX file", type=["csv", "xlsx", "docx"])
+# File Upload
+uploaded_file = st.file_uploader("Upload a CSV or Excel file with financial transactions", type=["csv", "xlsx"])
 
 if uploaded_file is not None:
     data = load_data(uploaded_file)
-    
+
     if data is not None and not data.empty:
-        st.write("### Uploaded Data Preview:")
+        st.write("### 📂 Uploaded Data Preview:")
         st.write(data.head())
 
-        # Generate financial statements
-        generate_general_entries(data)
-        generate_ledger(data)
-        generate_income_statement(data)
-        generate_cash_flow(data)
-        generate_balance_sheet(data)
+        journal_df = generate_journal_entries(data)
+        ledger = generate_ledger(journal_df)
+        net_income = generate_income_statement(journal_df)
+        generate_cash_flow(journal_df)
+        generate_balance_sheet(journal_df, net_income)
     else:
         st.error("The uploaded file contains no usable data.")
 
-
-