nanopy-bank 1.0.8__py3-none-any.whl

nanopy_bank/storage/sqlite_storage.py

@@ -0,0 +1,326 @@
+"""
+SQLite Storage - Database persistence for banking data
+"""
+
+import sqlite3
+import json
+from pathlib import Path
+from typing import Any, Optional, Dict, List
+from datetime import datetime
+from decimal import Decimal
+from contextlib import contextmanager
+
+
+class SQLiteStorage:
+    """
+    SQLite database storage for banking data
+    """
+
+    def __init__(self, data_dir: Optional[str] = None):
+        self.data_dir = Path(data_dir) if data_dir else Path.home() / ".nanopy-bank"
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = self.data_dir / "bank.db"
+        self._init_db()
+
+    def _init_db(self):
+        """Initialize database tables"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            # Customers table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS customers (
+                    customer_id TEXT PRIMARY KEY,
+                    first_name TEXT,
+                    last_name TEXT,
+                    email TEXT,
+                    phone TEXT,
+                    address TEXT,
+                    city TEXT,
+                    postal_code TEXT,
+                    country TEXT DEFAULT 'FR',
+                    birth_date TEXT,
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    data JSON
+                )
+            """)
+
+            # Accounts table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS accounts (
+                    iban TEXT PRIMARY KEY,
+                    bic TEXT DEFAULT 'NANPFRPP',
+                    account_type TEXT DEFAULT 'checking',
+                    currency TEXT DEFAULT 'EUR',
+                    balance TEXT DEFAULT '0.00',
+                    available_balance TEXT DEFAULT '0.00',
+                    overdraft_limit TEXT DEFAULT '0.00',
+                    customer_id TEXT,
+                    account_name TEXT,
+                    status TEXT DEFAULT 'active',
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    last_transaction TEXT,
+                    data JSON,
+                    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
+                )
+            """)
+
+            # Transactions table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS transactions (
+                    transaction_id TEXT PRIMARY KEY,
+                    reference TEXT,
+                    transaction_type TEXT,
+                    amount TEXT,
+                    currency TEXT DEFAULT 'EUR',
+                    from_iban TEXT,
+                    to_iban TEXT,
+                    account_iban TEXT,
+                    label TEXT,
+                    description TEXT,
+                    category TEXT,
+                    counterparty_name TEXT,
+                    counterparty_iban TEXT,
+                    counterparty_bic TEXT,
+                    status TEXT DEFAULT 'completed',
+                    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+                    executed_at TEXT,
+                    value_date TEXT,
+                    end_to_end_id TEXT,
+                    mandate_id TEXT,
+                    balance_after TEXT,
+                    data JSON,
+                    FOREIGN KEY (account_iban) REFERENCES accounts(iban)
+                )
+            """)
+
+            # Cards table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS cards (
+                    card_id TEXT PRIMARY KEY,
+                    card_number TEXT,
+                    card_type TEXT DEFAULT 'visa',
+                    expiry_month INTEGER,
+                    expiry_year INTEGER,
+                    status TEXT DEFAULT 'active',
+                    account_iban TEXT,
+                    daily_limit TEXT DEFAULT '1000.00',
+                    monthly_limit TEXT DEFAULT '5000.00',
+                    contactless_enabled INTEGER DEFAULT 1,
+                    online_payments_enabled INTEGER DEFAULT 1,
+                    data JSON,
+                    FOREIGN KEY (account_iban) REFERENCES accounts(iban)
+                )
+            """)
+
+            # Create indexes
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_transactions_account ON transactions(account_iban)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_transactions_date ON transactions(created_at)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_accounts_customer ON accounts(customer_id)")
+
+            conn.commit()
+
+    @contextmanager
+    def _get_connection(self):
+        """Get database connection with context manager"""
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+
+    # ========== CUSTOMERS ==========
+
+    def save_customer(self, customer: Dict):
+        """Save or update customer"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT OR REPLACE INTO customers
+                (customer_id, first_name, last_name, email, phone, address, city, postal_code, country, birth_date, created_at, data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                customer.get("customer_id"),
+                customer.get("first_name"),
+                customer.get("last_name"),
+                customer.get("email"),
+                customer.get("phone"),
+                customer.get("address"),
+                customer.get("city"),
+                customer.get("postal_code"),
+                customer.get("country", "FR"),
+                customer.get("birth_date"),
+                customer.get("created_at", datetime.now().isoformat()),
+                json.dumps(customer)
+            ))
+            conn.commit()
+
+    def get_customer(self, customer_id: str) -> Optional[Dict]:
+        """Get customer by ID"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM customers WHERE customer_id = ?", (customer_id,))
+            row = cursor.fetchone()
+            return json.loads(row["data"]) if row else None
+
+    def get_all_customers(self) -> List[Dict]:
+        """Get all customers"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM customers ORDER BY created_at DESC")
+            return [json.loads(row["data"]) for row in cursor.fetchall()]
+
+    # ========== ACCOUNTS ==========
+
+    def save_account(self, account: Dict):
+        """Save or update account"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT OR REPLACE INTO accounts
+                (iban, bic, account_type, currency, balance, available_balance, overdraft_limit,
+                 customer_id, account_name, status, created_at, last_transaction, data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                account.get("iban"),
+                account.get("bic", "NANPFRPP"),
+                account.get("account_type", "checking"),
+                account.get("currency", "EUR"),
+                str(account.get("balance", "0.00")),
+                str(account.get("available_balance", "0.00")),
+                str(account.get("overdraft_limit", "0.00")),
+                account.get("customer_id"),
+                account.get("account_name"),
+                account.get("status", "active"),
+                account.get("created_at", datetime.now().isoformat()),
+                account.get("last_transaction"),
+                json.dumps(account)
+            ))
+            conn.commit()
+
+    def get_account(self, iban: str) -> Optional[Dict]:
+        """Get account by IBAN"""
+        iban = iban.replace(" ", "").upper()
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM accounts WHERE iban = ?", (iban,))
+            row = cursor.fetchone()
+            return json.loads(row["data"]) if row else None
+
+    def get_all_accounts(self) -> List[Dict]:
+        """Get all accounts"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM accounts ORDER BY created_at DESC")
+            return [json.loads(row["data"]) for row in cursor.fetchall()]
+
+    def get_customer_accounts(self, customer_id: str) -> List[Dict]:
+        """Get accounts for a customer"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM accounts WHERE customer_id = ?", (customer_id,))
+            return [json.loads(row["data"]) for row in cursor.fetchall()]
+
+    # ========== TRANSACTIONS ==========
+
+    def save_transaction(self, transaction: Dict):
+        """Save transaction"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT OR REPLACE INTO transactions
+                (transaction_id, reference, transaction_type, amount, currency, from_iban, to_iban,
+                 account_iban, label, description, category, counterparty_name, counterparty_iban,
+                 counterparty_bic, status, created_at, executed_at, value_date, end_to_end_id,
+                 mandate_id, balance_after, data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                transaction.get("transaction_id"),
+                transaction.get("reference"),
+                transaction.get("transaction_type"),
+                str(transaction.get("amount", "0.00")),
+                transaction.get("currency", "EUR"),
+                transaction.get("from_iban"),
+                transaction.get("to_iban"),
+                transaction.get("account_iban"),
+                transaction.get("label"),
+                transaction.get("description"),
+                transaction.get("category"),
+                transaction.get("counterparty_name"),
+                transaction.get("counterparty_iban"),
+                transaction.get("counterparty_bic"),
+                transaction.get("status", "completed"),
+                transaction.get("created_at", datetime.now().isoformat()),
+                transaction.get("executed_at"),
+                transaction.get("value_date"),
+                transaction.get("end_to_end_id"),
+                transaction.get("mandate_id"),
+                str(transaction.get("balance_after", "")) if transaction.get("balance_after") else None,
+                json.dumps(transaction)
+            ))
+            conn.commit()
+
+    def get_transaction(self, transaction_id: str) -> Optional[Dict]:
+        """Get transaction by ID"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM transactions WHERE transaction_id = ?", (transaction_id,))
+            row = cursor.fetchone()
+            return json.loads(row["data"]) if row else None
+
+    def get_account_transactions(self, iban: str, limit: int = 50) -> List[Dict]:
+        """Get transactions for an account"""
+        iban = iban.replace(" ", "").upper()
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT data FROM transactions WHERE account_iban = ? ORDER BY created_at DESC LIMIT ?",
+                (iban, limit)
+            )
+            return [json.loads(row["data"]) for row in cursor.fetchall()]
+
+    def get_all_transactions(self, limit: int = 100) -> List[Dict]:
+        """Get all transactions"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT data FROM transactions ORDER BY created_at DESC LIMIT ?", (limit,))
+            return [json.loads(row["data"]) for row in cursor.fetchall()]
+
+    # ========== STATS ==========
+
+    def get_stats(self) -> Dict:
+        """Get database statistics"""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            cursor.execute("SELECT COUNT(*) FROM customers")
+            customer_count = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM accounts")
+            account_count = cursor.fetchone()[0]
+
+            cursor.execute("SELECT COUNT(*) FROM transactions")
+            transaction_count = cursor.fetchone()[0]
+
+            cursor.execute("SELECT SUM(CAST(balance AS REAL)) FROM accounts")
+            total_balance = cursor.fetchone()[0] or 0
+
+            return {
+                "customers": customer_count,
+                "accounts": account_count,
+                "transactions": transaction_count,
+                "total_balance": f"{total_balance:.2f}",
+            }
+
+
+# Singleton
+_sqlite_instance: Optional[SQLiteStorage] = None
+
+
+def get_sqlite_storage(data_dir: Optional[str] = None) -> SQLiteStorage:
+    """Get or create SQLite storage instance"""
+    global _sqlite_instance
+    if _sqlite_instance is None:
+        _sqlite_instance = SQLiteStorage(data_dir)
+    return _sqlite_instance

nanopy_bank/ui/__init__.py

@@ -0,0 +1,14 @@
+"""
+UI Module - Streamlit application
+"""
+
+from .pages import dashboard, accounts, transfers, cards, sepa, settings
+
+__all__ = [
+    "dashboard",
+    "accounts",
+    "transfers",
+    "cards",
+    "sepa",
+    "settings",
+]

nanopy_bank/ui/pages/__init__.py

@@ -0,0 +1,33 @@
+"""
+UI Pages - Each page in its own module
+"""
+
+from .dashboard import render_dashboard
+from .accounts import render_accounts
+from .transfers import render_transfers
+from .beneficiaries import render_beneficiaries
+from .cards import render_cards
+from .loans import render_loans
+from .fees import render_fees
+from .branches import render_branches
+from .sepa import render_sepa
+from .audit import render_audit
+from .settings import render_settings
+from .advisor import render_advisor
+from .holding import render_holding
+
+__all__ = [
+    "render_dashboard",
+    "render_accounts",
+    "render_transfers",
+    "render_beneficiaries",
+    "render_cards",
+    "render_loans",
+    "render_fees",
+    "render_branches",
+    "render_sepa",
+    "render_audit",
+    "render_settings",
+    "render_advisor",
+    "render_holding",
+]

nanopy_bank/ui/pages/accounts.py

@@ -0,0 +1,85 @@
+"""
+Accounts page
+"""
+
+import streamlit as st
+from decimal import Decimal
+
+from .common import format_currency, page_header
+
+
+def render_accounts():
+    """Render accounts page"""
+    page_header("Accounts")
+
+    bank = st.session_state.bank
+
+    if bank.accounts:
+        st.markdown("### Your Accounts")
+
+        for iban, account in bank.accounts.items():
+            with st.expander(f"💳 {account.account_name} - {account.format_iban()}", expanded=False):
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.markdown(f"**Balance:** {format_currency(account.balance, account.currency.value)}")
+                    st.markdown(f"**Available:** {format_currency(account.available_balance, account.currency.value)}")
+                    st.markdown(f"**Type:** {account.account_type.value.title()}")
+                with col2:
+                    st.markdown(f"**IBAN:** `{account.format_iban()}`")
+                    st.markdown(f"**BIC:** `{account.bic}`")
+                    st.markdown(f"**Status:** {account.status.value.title()}")
+
+    st.divider()
+
+    st.markdown("### Create New Account")
+
+    with st.form("create_account_form"):
+        col1, col2 = st.columns(2)
+
+        with col1:
+            if bank.customers:
+                customer_options = {f"{c.full_name} ({c.customer_id})": c.customer_id for c in bank.customers.values()}
+                customer_select = st.selectbox("Select Customer", options=["New Customer"] + list(customer_options.keys()))
+            else:
+                customer_select = "New Customer"
+
+            if customer_select == "New Customer":
+                first_name = st.text_input("First Name")
+                last_name = st.text_input("Last Name")
+                email = st.text_input("Email")
+            else:
+                first_name = last_name = email = None
+                selected_customer_id = customer_options[customer_select]
+
+        with col2:
+            from nanopy_bank.core import AccountType, Currency
+
+            account_name = st.text_input("Account Name", "Mon Compte")
+            account_type = st.selectbox("Account Type", [at.value for at in AccountType])
+            currency = st.selectbox("Currency", [c.value for c in Currency])
+            initial_balance = st.number_input("Initial Balance", min_value=0.0, value=0.0, step=100.0)
+
+        submitted = st.form_submit_button("Create Account")
+
+        if submitted:
+            try:
+                if customer_select == "New Customer":
+                    if not first_name or not last_name or not email:
+                        st.error("Please fill in all customer fields")
+                    else:
+                        customer = bank.create_customer(first_name, last_name, email)
+                        selected_customer_id = customer.customer_id
+                else:
+                    selected_customer_id = customer_options[customer_select]
+
+                account = bank.create_account(
+                    customer_id=selected_customer_id,
+                    account_type=AccountType(account_type),
+                    currency=Currency(currency),
+                    initial_balance=Decimal(str(initial_balance)),
+                    account_name=account_name
+                )
+                st.success(f"Account created: {account.format_iban()}")
+                st.rerun()
+            except Exception as e:
+                st.error(f"Error: {e}")

nanopy_bank/ui/pages/advisor.py

@@ -0,0 +1,140 @@
+"""
+Advisor page - Employee/Conseiller view
+"""
+
+import streamlit as st
+import pandas as pd
+
+from .common import page_header, format_currency
+
+
+def render_advisor():
+    """Render advisor dashboard"""
+    page_header("Espace Conseiller")
+
+    bank = st.session_state.bank
+
+    tab1, tab2, tab3, tab4 = st.tabs(["Mes Clients", "Demandes", "Objectifs", "Agenda"])
+
+    with tab1:
+        st.markdown("### Portefeuille Clients")
+
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Clients geres", len(bank.customers) or 42)
+        with col2:
+            st.metric("Encours total", "2.4M EUR")
+        with col3:
+            st.metric("RDV ce mois", 18)
+
+        st.divider()
+
+        # Client list
+        clients = [
+            {"name": "Jean Dupont", "status": "Premium", "balance": "45,000 EUR", "products": 4, "last_contact": "02/01/2026"},
+            {"name": "Marie Martin", "status": "Standard", "balance": "12,500 EUR", "products": 2, "last_contact": "28/12/2025"},
+            {"name": "Pierre Bernard", "status": "Pro", "balance": "85,000 EUR", "products": 6, "last_contact": "05/01/2026"},
+            {"name": "Sophie Petit", "status": "Jeune", "balance": "2,300 EUR", "products": 1, "last_contact": "15/12/2025"},
+        ]
+
+        for client in clients:
+            col1, col2, col3, col4, col5 = st.columns([2, 1, 2, 1, 1])
+            with col1:
+                st.markdown(f"**{client['name']}**")
+            with col2:
+                if client['status'] == 'Premium':
+                    st.success(client['status'])
+                elif client['status'] == 'Pro':
+                    st.info(client['status'])
+                else:
+                    st.caption(client['status'])
+            with col3:
+                st.markdown(f":green[{client['balance']}]")
+            with col4:
+                st.caption(f"{client['products']} produits")
+            with col5:
+                st.button("Fiche", key=f"client_{client['name']}")
+            st.divider()
+
+    with tab2:
+        st.markdown("### Demandes en attente")
+
+        requests = [
+            {"client": "Jean Dupont", "type": "Pret personnel", "amount": "15,000 EUR", "date": "04/01/2026", "priority": "High"},
+            {"client": "Pierre Bernard", "type": "Augmentation decouvert", "amount": "5,000 EUR", "date": "03/01/2026", "priority": "Medium"},
+            {"client": "Marie Martin", "type": "Carte Gold", "amount": "-", "date": "02/01/2026", "priority": "Low"},
+        ]
+
+        for req in requests:
+            col1, col2, col3, col4, col5 = st.columns([2, 2, 2, 1, 2])
+            with col1:
+                st.markdown(f"**{req['client']}**")
+                st.caption(req['type'])
+            with col2:
+                st.markdown(req['amount'])
+            with col3:
+                st.caption(req['date'])
+            with col4:
+                if req['priority'] == 'High':
+                    st.error("Urgent")
+                elif req['priority'] == 'Medium':
+                    st.warning("Normal")
+                else:
+                    st.info("Faible")
+            with col5:
+                c1, c2 = st.columns(2)
+                with c1:
+                    st.button("Approuver", key=f"approve_{req['client']}", type="primary")
+                with c2:
+                    st.button("Refuser", key=f"reject_{req['client']}")
+            st.divider()
+
+    with tab3:
+        st.markdown("### Objectifs Commerciaux")
+
+        objectives = [
+            {"name": "Ouvertures de compte", "current": 12, "target": 15, "percent": 80},
+            {"name": "Credits accordes", "current": 450000, "target": 500000, "percent": 90},
+            {"name": "Assurances vendues", "current": 8, "target": 12, "percent": 67},
+            {"name": "Cartes Premium", "current": 5, "target": 8, "percent": 62},
+        ]
+
+        for obj in objectives:
+            st.markdown(f"**{obj['name']}**")
+            st.progress(obj['percent'] / 100)
+            st.caption(f"{obj['current']:,} / {obj['target']:,} ({obj['percent']}%)")
+            st.divider()
+
+    with tab4:
+        st.markdown("### Agenda")
+
+        appointments = [
+            {"time": "09:00", "client": "Jean Dupont", "type": "Revue annuelle", "location": "Agence"},
+            {"time": "11:00", "client": "Marie Martin", "type": "Simulation pret", "location": "Telephone"},
+            {"time": "14:30", "client": "Pierre Bernard", "type": "Bilan pro", "location": "Agence"},
+            {"time": "16:00", "client": "Sophie Petit", "type": "Premier RDV", "location": "Agence"},
+        ]
+
+        for apt in appointments:
+            col1, col2, col3, col4 = st.columns([1, 2, 2, 1])
+            with col1:
+                st.markdown(f"**{apt['time']}**")
+            with col2:
+                st.markdown(apt['client'])
+            with col3:
+                st.caption(apt['type'])
+            with col4:
+                st.caption(apt['location'])
+            st.divider()
+
+        with st.expander("Planifier un RDV"):
+            with st.form("new_appointment"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.date_input("Date")
+                    st.time_input("Heure")
+                with col2:
+                    st.selectbox("Client", ["Jean Dupont", "Marie Martin", "Pierre Bernard", "Sophie Petit"])
+                    st.selectbox("Type", ["Revue annuelle", "Simulation pret", "Premier RDV", "Reclamation"])
+                if st.form_submit_button("Planifier"):
+                    st.success("RDV planifie!")

nanopy_bank/ui/pages/audit.py

@@ -0,0 +1,73 @@
+"""
+Audit page
+"""
+
+import streamlit as st
+
+from .common import page_header
+
+
+def render_audit():
+    """Render audit logs page"""
+    page_header("Security & Audit")
+
+    tab1, tab2 = st.tabs(["Activity Log", "Security Alerts"])
+
+    with tab1:
+        st.markdown("### Recent Activity")
+
+        logs = [
+            {"time": "05/01/2026 14:32", "action": "Login", "details": "Successful login from Paris, FR", "ip": "86.123.45.67"},
+            {"time": "05/01/2026 14:35", "action": "Transfer", "details": "SEPA transfer of 150.00 EUR", "ip": "86.123.45.67"},
+            {"time": "05/01/2026 14:40", "action": "Card Block", "details": "Temporary card block activated", "ip": "86.123.45.67"},
+            {"time": "04/01/2026 09:15", "action": "Login", "details": "Successful login from Lyon, FR", "ip": "92.184.12.34"},
+            {"time": "03/01/2026 18:22", "action": "Beneficiary", "details": "New beneficiary added", "ip": "86.123.45.67"},
+        ]
+
+        for log in logs:
+            col1, col2, col3 = st.columns([2, 4, 2])
+            with col1:
+                st.caption(log['time'])
+            with col2:
+                st.markdown(f"**{log['action']}**")
+                st.caption(log['details'])
+            with col3:
+                st.caption(f"IP: {log['ip']}")
+            st.divider()
+
+    with tab2:
+        st.markdown("### Security Alerts")
+
+        alerts = [
+            {"time": "02/01/2026 22:45", "type": "Unusual Location", "desc": "Login attempt from Germany", "status": "Blocked", "risk": "High"},
+            {"time": "28/12/2025 15:30", "type": "Large Transaction", "desc": "Transfer > 5,000 EUR detected", "status": "Verified", "risk": "Medium"},
+        ]
+
+        for alert in alerts:
+            col1, col2, col3, col4 = st.columns([2, 3, 2, 1])
+            with col1:
+                st.caption(alert['time'])
+                if alert['risk'] == 'High':
+                    st.error(f"Risk: {alert['risk']}")
+                else:
+                    st.warning(f"Risk: {alert['risk']}")
+            with col2:
+                st.markdown(f"**{alert['type']}**")
+                st.caption(alert['desc'])
+            with col3:
+                if alert['status'] == 'Blocked':
+                    st.error(alert['status'])
+                else:
+                    st.success(alert['status'])
+            with col4:
+                st.button("Details", key=f"alert_{alert['time']}")
+            st.divider()
+
+        st.markdown("### Security Settings")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.toggle("Two-Factor Authentication", value=True)
+            st.toggle("Login Notifications", value=True)
+        with col2:
+            st.toggle("Transaction Alerts", value=True)
+            st.toggle("Unusual Activity Alerts", value=True)