Accountant Expert

from decimal import Decimalfrom datetime import datetimefrom enum import Enumfrom typing import List
class AccountType(Enum):    ASSET = "asset"    LIABILITY = "liability"    EQUITY = "equity"    REVENUE = "revenue"    EXPENSE = "expense"
class Account:    def __init__(self, code: str, name: str, account_type: AccountType):        self.code = code        self.name = name        self.type = account_type        self.balance = Decimal('0')        self.debit_total = Decimal('0')        self.credit_total = Decimal('0')
    def is_debit_normal(self) -> bool:        """Check if account has normal debit balance"""        return self.type in [AccountType.ASSET, AccountType.EXPENSE]
class JournalEntry:    def __init__(self, date: datetime, description: str):        self.id = self.generate_entry_id()        self.date = date        self.description = description        self.lines = []        self.posted = False
    def add_line(self, account: Account, debit: Decimal = None,                 credit: Decimal = None):        """Add line to journal entry"""        if debit and credit:            raise ValueError("Cannot have both debit and credit")
        self.lines.append({            "account": account,            "debit": debit or Decimal('0'),            "credit": credit or Decimal('0')        })
    def validate(self) -> bool:        """Validate journal entry (debits must equal credits)"""        total_debits = sum(line["debit"] for line in self.lines)        total_credits = sum(line["credit"] for line in self.lines)
        return total_debits == total_credits
    def post(self) -> bool:        """Post journal entry to ledger"""        if not self.validate():            raise ValueError("Entry does not balance")
        for line in self.lines:            account = line["account"]            if line["debit"]:                account.debit_total += line["debit"]            if line["credit"]:                account.credit_total += line["credit"]
            # Update balance based on account type            if account.is_debit_normal():                account.balance = account.debit_total - account.credit_total            else:                account.balance = account.credit_total - account.debit_total
        self.posted = True        return True

class FinancialStatements:    def __init__(self, company_name: str, period_end: datetime):        self.company_name = company_name        self.period_end = period_end        self.accounts = []
    def generate_balance_sheet(self) -> dict:        """Generate balance sheet"""        assets = self.sum_accounts_by_type(AccountType.ASSET)        liabilities = self.sum_accounts_by_type(AccountType.LIABILITY)        equity = self.sum_accounts_by_type(AccountType.EQUITY)
        # Calculate retained earnings        revenue = self.sum_accounts_by_type(AccountType.REVENUE)        expenses = self.sum_accounts_by_type(AccountType.EXPENSE)        net_income = revenue - expenses
        total_equity = equity + net_income
        return {            "company": self.company_name,            "period_end": self.period_end,            "assets": {                "current_assets": self.get_current_assets(),                "non_current_assets": self.get_non_current_assets(),                "total": assets            },            "liabilities": {                "current_liabilities": self.get_current_liabilities(),                "non_current_liabilities": self.get_non_current_liabilities(),                "total": liabilities            },            "equity": {                "share_capital": equity,                "retained_earnings": net_income,                "total": total_equity            },            "balanced": assets == (liabilities + total_equity)        }
    def generate_income_statement(self, period_start: datetime,                                   period_end: datetime) -> dict:        """Generate income statement (P&L)"""        revenue = self.sum_accounts_by_type(AccountType.REVENUE)        expenses = self.sum_accounts_by_type(AccountType.EXPENSE)
        gross_profit = revenue - self.get_cogs()        operating_expenses = self.get_operating_expenses()        operating_income = gross_profit - operating_expenses
        interest_expense = self.get_interest_expense()        tax_expense = self.calculate_tax(operating_income - interest_expense)
        net_income = operating_income - interest_expense - tax_expense
        return {            "company": self.company_name,            "period": f"{period_start.date()} to {period_end.date()}",            "revenue": revenue,            "cogs": self.get_cogs(),            "gross_profit": gross_profit,            "operating_expenses": operating_expenses,            "operating_income": operating_income,            "interest_expense": interest_expense,            "tax_expense": tax_expense,            "net_income": net_income,            "eps": self.calculate_eps(net_income)        }
    def generate_cash_flow_statement(self) -> dict:        """Generate cash flow statement"""        return {            "operating_activities": self.calculate_operating_cash_flow(),            "investing_activities": self.calculate_investing_cash_flow(),            "financing_activities": self.calculate_financing_cash_flow(),            "net_change_in_cash": self.calculate_net_cash_change(),            "beginning_cash": self.get_beginning_cash(),            "ending_cash": self.get_ending_cash()        }

class TaxCalculator:    def calculate_corporate_tax(self, taxable_income: Decimal,                                jurisdiction: str = "US") -> dict:        """Calculate corporate income tax"""        if jurisdiction == "US":            tax_rate = Decimal('0.21')  # Federal rate        elif jurisdiction == "UK":            tax_rate = Decimal('0.19')        else:            tax_rate = Decimal('0.25')  # Default rate
        tax_amount = taxable_income * tax_rate
        return {            "taxable_income": taxable_income,            "tax_rate": tax_rate,            "tax_amount": tax_amount.quantize(Decimal('0.01')),            "effective_rate": tax_rate,            "jurisdiction": jurisdiction        }
    def calculate_vat(self, net_amount: Decimal, vat_rate: Decimal) -> dict:        """Calculate VAT/Sales tax"""        vat_amount = net_amount * vat_rate        gross_amount = net_amount + vat_amount
        return {            "net_amount": net_amount,            "vat_rate": vat_rate,            "vat_amount": vat_amount.quantize(Decimal('0.01')),            "gross_amount": gross_amount.quantize(Decimal('0.01'))        }
    def calculate_depreciation(self, cost: Decimal, salvage_value: Decimal,                              useful_life_years: int,                              method: str = "straight_line") -> List[dict]:        """Calculate depreciation schedule"""        if method == "straight_line":            annual_depreciation = (cost - salvage_value) / useful_life_years
            schedule = []            book_value = cost
            for year in range(1, useful_life_years + 1):                depreciation = annual_depreciation                book_value -= depreciation
                schedule.append({                    "year": year,                    "depreciation": depreciation.quantize(Decimal('0.01')),                    "accumulated_depreciation": (annual_depreciation * year).quantize(Decimal('0.01')),                    "book_value": book_value.quantize(Decimal('0.01'))                })
            return schedule

class FinancialRatios:    @staticmethod    def current_ratio(current_assets: Decimal, current_liabilities: Decimal) -> Decimal:        """Liquidity ratio: Current Assets / Current Liabilities"""        return (current_assets / current_liabilities).quantize(Decimal('0.01'))
    @staticmethod    def quick_ratio(current_assets: Decimal, inventory: Decimal,                    current_liabilities: Decimal) -> Decimal:        """Acid test: (Current Assets - Inventory) / Current Liabilities"""        return ((current_assets - inventory) / current_liabilities).quantize(Decimal('0.01'))
    @staticmethod    def debt_to_equity(total_debt: Decimal, total_equity: Decimal) -> Decimal:        """Leverage ratio: Total Debt / Total Equity"""        return (total_debt / total_equity).quantize(Decimal('0.01'))
    @staticmethod    def return_on_equity(net_income: Decimal, shareholders_equity: Decimal) -> Decimal:        """ROE: Net Income / Shareholders' Equity"""        return (net_income / shareholders_equity * 100).quantize(Decimal('0.01'))
    @staticmethod    def return_on_assets(net_income: Decimal, total_assets: Decimal) -> Decimal:        """ROA: Net Income / Total Assets"""        return (net_income / total_assets * 100).quantize(Decimal('0.01'))
    @staticmethod    def profit_margin(net_income: Decimal, revenue: Decimal) -> Decimal:        """Net Profit Margin: Net Income / Revenue"""        return (net_income / revenue * 100).quantize(Decimal('0.01'))