nanopy-bank 1.0.8__py3-none-any.whl

nanopy_bank/core/bank.py

@@ -0,0 +1,407 @@
+"""
+Bank - Core banking logic
+"""
+
+import json
+import os
+from datetime import datetime
+from decimal import Decimal
+from typing import Optional, List, Dict
+from pathlib import Path
+
+from .models import (
+    Account, Transaction, Customer, Card,
+    TransactionType, AccountType, AccountStatus, Currency
+)
+
+
+class Bank:
+    """
+    Core banking system - manages accounts, transactions, customers
+    """
+
+    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)
+
+        # In-memory storage (loaded from JSON files)
+        self.customers: Dict[str, Customer] = {}
+        self.accounts: Dict[str, Account] = {}  # Key = IBAN
+        self.transactions: Dict[str, Transaction] = {}
+        self.cards: Dict[str, Card] = {}
+
+        # Load existing data
+        self._load_data()
+
+    # ========== DATA PERSISTENCE ==========
+
+    def _load_data(self):
+        """Load data from JSON files"""
+        # Load customers
+        customers_file = self.data_dir / "customers.json"
+        if customers_file.exists():
+            with open(customers_file, "r") as f:
+                data = json.load(f)
+                for cust_data in data:
+                    # Remove computed properties that shouldn't be passed to constructor
+                    cust_data.pop("full_name", None)
+                    if cust_data.get("created_at"):
+                        cust_data["created_at"] = datetime.fromisoformat(cust_data["created_at"])
+                    if cust_data.get("birth_date"):
+                        cust_data["birth_date"] = datetime.fromisoformat(cust_data["birth_date"])
+                    cust = Customer(**cust_data)
+                    self.customers[cust.customer_id] = cust
+
+        # Load accounts
+        accounts_file = self.data_dir / "accounts.json"
+        if accounts_file.exists():
+            with open(accounts_file, "r") as f:
+                data = json.load(f)
+                for acc_data in data:
+                    # Remove computed properties
+                    acc_data.pop("iban_formatted", None)
+                    acc_data["account_type"] = AccountType(acc_data["account_type"])
+                    acc_data["currency"] = Currency(acc_data["currency"])
+                    acc_data["status"] = AccountStatus(acc_data["status"])
+                    acc_data["balance"] = Decimal(acc_data["balance"])
+                    acc_data["available_balance"] = Decimal(acc_data["available_balance"])
+                    acc_data["overdraft_limit"] = Decimal(acc_data["overdraft_limit"])
+                    if acc_data.get("created_at"):
+                        acc_data["created_at"] = datetime.fromisoformat(acc_data["created_at"])
+                    if acc_data.get("last_transaction"):
+                        acc_data["last_transaction"] = datetime.fromisoformat(acc_data["last_transaction"])
+                    acc = Account(**acc_data)
+                    self.accounts[acc.iban] = acc
+
+        # Load transactions
+        transactions_file = self.data_dir / "transactions.json"
+        if transactions_file.exists():
+            with open(transactions_file, "r") as f:
+                data = json.load(f)
+                for tx_data in data:
+                    # Remove computed properties
+                    tx_data.pop("signed_amount", None)
+                    tx_data.pop("is_credit", None)
+                    tx_data.pop("is_debit", None)
+                    tx_data["transaction_type"] = TransactionType(tx_data["transaction_type"])
+                    tx_data["currency"] = Currency(tx_data["currency"])
+                    tx_data["amount"] = Decimal(tx_data["amount"])
+                    if tx_data.get("balance_after"):
+                        tx_data["balance_after"] = Decimal(tx_data["balance_after"])
+                    if tx_data.get("created_at"):
+                        tx_data["created_at"] = datetime.fromisoformat(tx_data["created_at"])
+                    if tx_data.get("executed_at"):
+                        tx_data["executed_at"] = datetime.fromisoformat(tx_data["executed_at"])
+                    if tx_data.get("value_date"):
+                        tx_data["value_date"] = datetime.fromisoformat(tx_data["value_date"])
+                    tx = Transaction(**tx_data)
+                    self.transactions[tx.transaction_id] = tx
+
+        print(f"[BANK] Loaded {len(self.customers)} customers, {len(self.accounts)} accounts, {len(self.transactions)} transactions")
+
+    def _save_data(self):
+        """Save data to JSON files"""
+        # Save customers
+        customers_data = [c.to_dict() for c in self.customers.values()]
+        with open(self.data_dir / "customers.json", "w") as f:
+            json.dump(customers_data, f, indent=2, default=str)
+
+        # Save accounts
+        accounts_data = []
+        for acc in self.accounts.values():
+            d = acc.to_dict()
+            d["account_type"] = acc.account_type.value
+            d["currency"] = acc.currency.value
+            d["status"] = acc.status.value
+            accounts_data.append(d)
+        with open(self.data_dir / "accounts.json", "w") as f:
+            json.dump(accounts_data, f, indent=2, default=str)
+
+        # Save transactions
+        transactions_data = []
+        for tx in self.transactions.values():
+            d = tx.to_dict()
+            d["transaction_type"] = tx.transaction_type.value
+            d["currency"] = tx.currency.value
+            transactions_data.append(d)
+        with open(self.data_dir / "transactions.json", "w") as f:
+            json.dump(transactions_data, f, indent=2, default=str)
+
+    # ========== CUSTOMERS ==========
+
+    def create_customer(
+        self,
+        first_name: str,
+        last_name: str,
+        email: str,
+        phone: str = "",
+        address: str = "",
+        city: str = "",
+        postal_code: str = "",
+        country: str = "FR"
+    ) -> Customer:
+        """Create a new customer"""
+        customer = Customer(
+            first_name=first_name,
+            last_name=last_name,
+            email=email,
+            phone=phone,
+            address=address,
+            city=city,
+            postal_code=postal_code,
+            country=country
+        )
+        self.customers[customer.customer_id] = customer
+        self._save_data()
+        print(f"[BANK] Created customer: {customer.full_name} ({customer.customer_id})")
+        return customer
+
+    def get_customer(self, customer_id: str) -> Optional[Customer]:
+        """Get customer by ID"""
+        return self.customers.get(customer_id)
+
+    def get_customer_accounts(self, customer_id: str) -> List[Account]:
+        """Get all accounts for a customer"""
+        return [acc for acc in self.accounts.values() if acc.customer_id == customer_id]
+
+    # ========== ACCOUNTS ==========
+
+    def create_account(
+        self,
+        customer_id: str,
+        account_type: AccountType = AccountType.CHECKING,
+        currency: Currency = Currency.EUR,
+        initial_balance: Decimal = Decimal("0.00"),
+        overdraft_limit: Decimal = Decimal("0.00"),
+        account_name: str = ""
+    ) -> Account:
+        """Create a new account"""
+        if customer_id not in self.customers:
+            raise ValueError(f"Customer {customer_id} not found")
+
+        account = Account(
+            customer_id=customer_id,
+            account_type=account_type,
+            currency=currency,
+            balance=initial_balance,
+            available_balance=initial_balance,
+            overdraft_limit=overdraft_limit,
+            account_name=account_name
+        )
+        self.accounts[account.iban] = account
+        self._save_data()
+        print(f"[BANK] Created account: {account.iban} for customer {customer_id}")
+        return account
+
+    def get_account(self, iban: str) -> Optional[Account]:
+        """Get account by IBAN"""
+        # Normalize IBAN (remove spaces)
+        iban = iban.replace(" ", "").upper()
+        return self.accounts.get(iban)
+
+    def get_account_balance(self, iban: str) -> Optional[Decimal]:
+        """Get account balance"""
+        account = self.get_account(iban)
+        return account.balance if account else None
+
+    def get_account_transactions(self, iban: str, limit: int = 50) -> List[Transaction]:
+        """Get transactions for an account"""
+        iban = iban.replace(" ", "").upper()
+        txs = [tx for tx in self.transactions.values() if tx.account_iban == iban]
+        txs.sort(key=lambda x: x.created_at, reverse=True)
+        return txs[:limit]
+
+    # ========== TRANSACTIONS ==========
+
+    def credit(
+        self,
+        iban: str,
+        amount: Decimal,
+        label: str,
+        counterparty_name: str = "",
+        counterparty_iban: str = "",
+        transaction_type: TransactionType = TransactionType.CREDIT,
+        description: str = "",
+        category: str = ""
+    ) -> Transaction:
+        """Credit an account (add money)"""
+        account = self.get_account(iban)
+        if not account:
+            raise ValueError(f"Account {iban} not found")
+
+        if account.status != AccountStatus.ACTIVE:
+            raise ValueError(f"Account {iban} is not active")
+
+        # Update balance
+        account.balance += amount
+        account.available_balance += amount
+        account.last_transaction = datetime.now()
+
+        # Create transaction
+        tx = Transaction(
+            transaction_type=transaction_type,
+            amount=amount,
+            currency=account.currency,
+            account_iban=account.iban,
+            to_iban=account.iban,
+            from_iban=counterparty_iban or None,
+            label=label,
+            description=description,
+            category=category,
+            counterparty_name=counterparty_name,
+            counterparty_iban=counterparty_iban or None,
+            balance_after=account.balance
+        )
+        self.transactions[tx.transaction_id] = tx
+        self._save_data()
+
+        print(f"[BANK] Credit {amount} {account.currency.value} to {iban}: {label}")
+        return tx
+
+    def debit(
+        self,
+        iban: str,
+        amount: Decimal,
+        label: str,
+        counterparty_name: str = "",
+        counterparty_iban: str = "",
+        transaction_type: TransactionType = TransactionType.DEBIT,
+        description: str = "",
+        category: str = ""
+    ) -> Transaction:
+        """Debit an account (remove money)"""
+        account = self.get_account(iban)
+        if not account:
+            raise ValueError(f"Account {iban} not found")
+
+        if not account.can_debit(amount):
+            raise ValueError(f"Insufficient funds in account {iban}")
+
+        # Update balance
+        account.balance -= amount
+        account.available_balance -= amount
+        account.last_transaction = datetime.now()
+
+        # Create transaction
+        tx = Transaction(
+            transaction_type=transaction_type,
+            amount=amount,
+            currency=account.currency,
+            account_iban=account.iban,
+            from_iban=account.iban,
+            to_iban=counterparty_iban or None,
+            label=label,
+            description=description,
+            category=category,
+            counterparty_name=counterparty_name,
+            counterparty_iban=counterparty_iban or None,
+            balance_after=account.balance
+        )
+        self.transactions[tx.transaction_id] = tx
+        self._save_data()
+
+        print(f"[BANK] Debit {amount} {account.currency.value} from {iban}: {label}")
+        return tx
+
+    def transfer(
+        self,
+        from_iban: str,
+        to_iban: str,
+        amount: Decimal,
+        label: str,
+        description: str = ""
+    ) -> tuple:
+        """Transfer money between accounts"""
+        from_account = self.get_account(from_iban)
+        to_account = self.get_account(to_iban)
+
+        if not from_account:
+            raise ValueError(f"Source account {from_iban} not found")
+
+        # Debit source account
+        debit_tx = self.debit(
+            from_iban,
+            amount,
+            f"Virement vers {to_iban[-4:]}",
+            counterparty_name=to_account.account_name if to_account else "",
+            counterparty_iban=to_iban,
+            transaction_type=TransactionType.TRANSFER,
+            description=description
+        )
+
+        # Credit destination account (if internal)
+        credit_tx = None
+        if to_account:
+            credit_tx = self.credit(
+                to_iban,
+                amount,
+                f"Virement de {from_iban[-4:]}",
+                counterparty_name=from_account.account_name,
+                counterparty_iban=from_iban,
+                transaction_type=TransactionType.TRANSFER,
+                description=description
+            )
+
+        print(f"[BANK] Transfer {amount} EUR from {from_iban} to {to_iban}")
+        return debit_tx, credit_tx
+
+    # ========== SEPA ==========
+
+    def sepa_credit_transfer(
+        self,
+        from_iban: str,
+        to_iban: str,
+        to_bic: str,
+        to_name: str,
+        amount: Decimal,
+        label: str,
+        end_to_end_id: str = ""
+    ) -> Transaction:
+        """Execute a SEPA Credit Transfer"""
+        tx = self.debit(
+            from_iban,
+            amount,
+            label,
+            counterparty_name=to_name,
+            counterparty_iban=to_iban,
+            transaction_type=TransactionType.SEPA_CREDIT,
+            description=f"SEPA Credit Transfer to {to_name}"
+        )
+        tx.counterparty_bic = to_bic
+        tx.end_to_end_id = end_to_end_id or tx.reference
+        self._save_data()
+        return tx
+
+    # ========== STATISTICS ==========
+
+    def get_stats(self) -> dict:
+        """Get bank statistics"""
+        total_balance = sum(acc.balance for acc in self.accounts.values())
+        total_transactions = len(self.transactions)
+
+        return {
+            "total_customers": len(self.customers),
+            "total_accounts": len(self.accounts),
+            "total_transactions": total_transactions,
+            "total_balance": str(total_balance),
+            "accounts_by_type": {
+                at.value: len([a for a in self.accounts.values() if a.account_type == at])
+                for at in AccountType
+            },
+            "transactions_today": len([
+                tx for tx in self.transactions.values()
+                if tx.created_at.date() == datetime.now().date()
+            ])
+        }
+
+
+# Singleton instance
+_bank_instance: Optional[Bank] = None
+
+
+def get_bank(data_dir: Optional[str] = None) -> Bank:
+    """Get or create bank instance"""
+    global _bank_instance
+    if _bank_instance is None:
+        _bank_instance = Bank(data_dir)
+    return _bank_instance

nanopy_bank/core/beneficiary.py

@@ -0,0 +1,258 @@
+"""
+Beneficiary Models - Contacts for transfers, Standing Orders, SEPA Mandates
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime, date
+from decimal import Decimal
+from enum import Enum
+from typing import Optional, List
+import uuid
+
+
+class MandateStatus(Enum):
+    """SEPA Mandate status"""
+    ACTIVE = "active"
+    SUSPENDED = "suspended"
+    CANCELLED = "cancelled"
+    EXPIRED = "expired"
+
+
+class MandateType(Enum):
+    """SEPA Mandate type"""
+    CORE = "core"      # Particuliers
+    B2B = "b2b"        # Entreprises
+
+
+class OrderFrequency(Enum):
+    """Standing order frequency"""
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    BIWEEKLY = "biweekly"
+    MONTHLY = "monthly"
+    QUARTERLY = "quarterly"
+    YEARLY = "yearly"
+
+
+class OrderStatus(Enum):
+    """Standing order status"""
+    ACTIVE = "active"
+    PAUSED = "paused"
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+
+
+@dataclass
+class Beneficiary:
+    """
+    Saved beneficiary for quick transfers
+    """
+    beneficiary_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8].upper())
+    customer_id: str = ""  # Owner of this beneficiary
+
+    # Beneficiary info
+    name: str = ""
+    iban: str = ""
+    bic: str = ""
+
+    # Additional info
+    alias: str = ""  # Nickname (e.g., "Mom", "Landlord")
+    email: str = ""
+    phone: str = ""
+    address: str = ""
+    country: str = "FR"
+
+    # Categorization
+    category: str = ""  # "family", "business", "bills", etc.
+    is_favorite: bool = False
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+    last_used: Optional[datetime] = None
+    use_count: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "beneficiary_id": self.beneficiary_id,
+            "customer_id": self.customer_id,
+            "name": self.name,
+            "iban": self.iban,
+            "iban_formatted": self.format_iban(),
+            "bic": self.bic,
+            "alias": self.alias,
+            "email": self.email,
+            "phone": self.phone,
+            "address": self.address,
+            "country": self.country,
+            "category": self.category,
+            "is_favorite": self.is_favorite,
+            "created_at": self.created_at.isoformat(),
+            "last_used": self.last_used.isoformat() if self.last_used else None,
+            "use_count": self.use_count,
+        }
+
+    def format_iban(self) -> str:
+        """Format IBAN with spaces"""
+        return " ".join([self.iban[i:i+4] for i in range(0, len(self.iban), 4)])
+
+
+@dataclass
+class StandingOrder:
+    """
+    Recurring transfer order (virement permanent)
+    """
+    order_id: str = field(default_factory=lambda: f"SO{uuid.uuid4().hex[:10].upper()}")
+
+    # Source
+    from_iban: str = ""
+    customer_id: str = ""
+
+    # Destination
+    to_iban: str = ""
+    to_bic: str = ""
+    to_name: str = ""
+    beneficiary_id: Optional[str] = None  # Link to saved beneficiary
+
+    # Amount
+    amount: Decimal = Decimal("0.00")
+    currency: str = "EUR"
+
+    # Schedule
+    frequency: OrderFrequency = OrderFrequency.MONTHLY
+    start_date: date = field(default_factory=date.today)
+    end_date: Optional[date] = None  # None = no end
+    next_execution: Optional[date] = None
+    execution_day: int = 1  # Day of month (1-28)
+
+    # Details
+    label: str = ""
+    reference: str = ""
+    category: str = ""
+
+    # Status
+    status: OrderStatus = OrderStatus.ACTIVE
+    execution_count: int = 0
+    last_execution: Optional[datetime] = None
+    last_status: str = ""  # "success", "failed", "insufficient_funds"
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+    def __post_init__(self):
+        if not self.next_execution:
+            self.next_execution = self.start_date
+
+    def to_dict(self) -> dict:
+        return {
+            "order_id": self.order_id,
+            "from_iban": self.from_iban,
+            "customer_id": self.customer_id,
+            "to_iban": self.to_iban,
+            "to_bic": self.to_bic,
+            "to_name": self.to_name,
+            "beneficiary_id": self.beneficiary_id,
+            "amount": str(self.amount),
+            "currency": self.currency,
+            "frequency": self.frequency.value,
+            "start_date": self.start_date.isoformat(),
+            "end_date": self.end_date.isoformat() if self.end_date else None,
+            "next_execution": self.next_execution.isoformat() if self.next_execution else None,
+            "execution_day": self.execution_day,
+            "label": self.label,
+            "reference": self.reference,
+            "category": self.category,
+            "status": self.status.value,
+            "execution_count": self.execution_count,
+            "last_execution": self.last_execution.isoformat() if self.last_execution else None,
+            "last_status": self.last_status,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+        }
+
+
+@dataclass
+class SEPAMandate:
+    """
+    SEPA Direct Debit Mandate (Mandat de prélèvement)
+    """
+    mandate_id: str = field(default_factory=lambda: f"MNDT{uuid.uuid4().hex[:12].upper()}")
+
+    # Debtor (the account holder giving permission)
+    debtor_iban: str = ""
+    debtor_bic: str = ""
+    debtor_name: str = ""
+    customer_id: str = ""
+
+    # Creditor (the one who will collect)
+    creditor_id: str = ""  # SEPA Creditor Identifier
+    creditor_name: str = ""
+    creditor_iban: str = ""
+    creditor_bic: str = ""
+
+    # Mandate details
+    mandate_type: MandateType = MandateType.CORE
+    signature_date: date = field(default_factory=date.today)
+    signature_location: str = ""
+
+    # Limits
+    max_amount: Optional[Decimal] = None  # Max per debit
+    max_frequency: Optional[str] = None   # "monthly", "quarterly", etc.
+
+    # Status
+    status: MandateStatus = MandateStatus.ACTIVE
+
+    # Sequence tracking
+    sequence_type: str = "FRST"  # FRST, RCUR, OOFF, FNAL
+    first_collection_date: Optional[date] = None
+    last_collection_date: Optional[date] = None
+    collection_count: int = 0
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    cancelled_at: Optional[datetime] = None
+    cancellation_reason: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "mandate_id": self.mandate_id,
+            "debtor_iban": self.debtor_iban,
+            "debtor_bic": self.debtor_bic,
+            "debtor_name": self.debtor_name,
+            "customer_id": self.customer_id,
+            "creditor_id": self.creditor_id,
+            "creditor_name": self.creditor_name,
+            "creditor_iban": self.creditor_iban,
+            "creditor_bic": self.creditor_bic,
+            "mandate_type": self.mandate_type.value,
+            "signature_date": self.signature_date.isoformat(),
+            "signature_location": self.signature_location,
+            "max_amount": str(self.max_amount) if self.max_amount else None,
+            "max_frequency": self.max_frequency,
+            "status": self.status.value,
+            "sequence_type": self.sequence_type,
+            "first_collection_date": self.first_collection_date.isoformat() if self.first_collection_date else None,
+            "last_collection_date": self.last_collection_date.isoformat() if self.last_collection_date else None,
+            "collection_count": self.collection_count,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "cancelled_at": self.cancelled_at.isoformat() if self.cancelled_at else None,
+            "cancellation_reason": self.cancellation_reason,
+        }
+
+    def can_collect(self, amount: Decimal) -> bool:
+        """Check if a collection is allowed"""
+        if self.status != MandateStatus.ACTIVE:
+            return False
+        if self.max_amount and amount > self.max_amount:
+            return False
+        return True
+
+    def update_sequence(self):
+        """Update sequence type after collection"""
+        self.collection_count += 1
+        if self.sequence_type == "FRST":
+            self.sequence_type = "RCUR"
+        self.last_collection_date = date.today()
+        self.updated_at = datetime.now()