nanopy-bank 1.0.8__py3-none-any.whl

nanopy_bank/core/models.py

@@ -0,0 +1,308 @@
+"""
+Banking Models - Account, Transaction, Customer
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from decimal import Decimal
+from enum import Enum
+from typing import Optional, List
+import uuid
+import hashlib
+
+
+class TransactionType(Enum):
+    """Transaction types"""
+    CREDIT = "credit"  # Money in
+    DEBIT = "debit"    # Money out
+    TRANSFER = "transfer"
+    CREDIT_TRANSFER = "credit_transfer"  # Virement
+    DIRECT_DEBIT = "direct_debit"  # Prelevement
+    SEPA_CREDIT = "sepa_credit"
+    SEPA_DEBIT = "sepa_debit"
+    CARD_PAYMENT = "card_payment"
+    ATM_WITHDRAWAL = "atm_withdrawal"
+    FEE = "fee"
+    INTEREST = "interest"
+    REFUND = "refund"
+
+
+class AccountType(Enum):
+    """Account types"""
+    CHECKING = "checking"      # Compte courant
+    SAVINGS = "savings"        # Livret d'épargne
+    BUSINESS = "business"      # Compte professionnel
+    JOINT = "joint"            # Compte joint
+
+
+class AccountStatus(Enum):
+    """Account status"""
+    ACTIVE = "active"
+    BLOCKED = "blocked"
+    CLOSED = "closed"
+    PENDING = "pending"
+
+
+class Currency(Enum):
+    """Supported currencies"""
+    EUR = "EUR"
+    USD = "USD"
+    GBP = "GBP"
+    CHF = "CHF"
+
+
+class CardType(Enum):
+    """Card types"""
+    DEBIT = "debit"
+    CREDIT = "credit"
+    PREPAID = "prepaid"
+    BUSINESS = "business"
+
+
+class CardStatus(Enum):
+    """Card status"""
+    ACTIVE = "active"
+    BLOCKED = "blocked"
+    EXPIRED = "expired"
+    PENDING = "pending"
+
+
+@dataclass
+class Customer:
+    """Bank customer"""
+    customer_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8].upper())
+    first_name: str = ""
+    last_name: str = ""
+    email: str = ""
+    phone: str = ""
+    address: str = ""
+    city: str = ""
+    postal_code: str = ""
+    country: str = "FR"
+    birth_date: Optional[datetime] = None
+    created_at: datetime = field(default_factory=datetime.now)
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.first_name} {self.last_name}"
+
+    def to_dict(self) -> dict:
+        return {
+            "customer_id": self.customer_id,
+            "first_name": self.first_name,
+            "last_name": self.last_name,
+            "full_name": self.full_name,
+            "email": self.email,
+            "phone": self.phone,
+            "address": self.address,
+            "city": self.city,
+            "postal_code": self.postal_code,
+            "country": self.country,
+            "birth_date": self.birth_date.isoformat() if self.birth_date else None,
+            "created_at": self.created_at.isoformat(),
+        }
+
+
+@dataclass
+class Account:
+    """Bank account"""
+    iban: str = ""
+    bic: str = "NANPFRPP"  # Default BIC for NanoPy Bank
+    account_type: AccountType = AccountType.CHECKING
+    currency: Currency = Currency.EUR
+    balance: Decimal = Decimal("0.00")
+    available_balance: Decimal = Decimal("0.00")
+    overdraft_limit: Decimal = Decimal("0.00")
+    customer_id: str = ""
+    account_name: str = ""
+    status: AccountStatus = AccountStatus.ACTIVE
+    created_at: datetime = field(default_factory=datetime.now)
+    last_transaction: Optional[datetime] = None
+
+    # Card info (optional)
+    card_number: Optional[str] = None
+    card_expiry: Optional[str] = None
+    card_cvv: Optional[str] = None
+
+    def __post_init__(self):
+        if not self.iban:
+            self.iban = self._generate_iban()
+        if not self.account_name:
+            self.account_name = f"Compte {self.account_type.value}"
+
+    def _generate_iban(self) -> str:
+        """Generate a valid French IBAN"""
+        # Bank code (5 digits) + Branch code (5 digits) + Account number (11 digits) + Key (2 digits)
+        bank_code = "30001"  # NanoPy Bank code
+        branch_code = "00001"
+        account_num = str(uuid.uuid4().int)[:11].zfill(11)
+
+        # Calculate check digits (simplified)
+        bban = f"{bank_code}{branch_code}{account_num}00"
+        # Convert letters to numbers (A=10, B=11, etc.)
+        numeric = ""
+        for char in f"{bban}FR00":
+            if char.isalpha():
+                numeric += str(ord(char.upper()) - 55)
+            else:
+                numeric += char
+
+        check = 98 - (int(numeric) % 97)
+        return f"FR{check:02d}{bank_code}{branch_code}{account_num}00"
+
+    def can_debit(self, amount: Decimal) -> bool:
+        """Check if account can be debited"""
+        return self.status == AccountStatus.ACTIVE and \
+               (self.available_balance + self.overdraft_limit) >= amount
+
+    def to_dict(self) -> dict:
+        return {
+            "iban": self.iban,
+            "iban_formatted": self.format_iban(),
+            "bic": self.bic,
+            "account_type": self.account_type.value,
+            "currency": self.currency.value,
+            "balance": str(self.balance),
+            "available_balance": str(self.available_balance),
+            "overdraft_limit": str(self.overdraft_limit),
+            "customer_id": self.customer_id,
+            "account_name": self.account_name,
+            "status": self.status.value,
+            "created_at": self.created_at.isoformat(),
+            "last_transaction": self.last_transaction.isoformat() if self.last_transaction else None,
+        }
+
+    def format_iban(self) -> str:
+        """Format IBAN with spaces every 4 characters"""
+        return " ".join([self.iban[i:i+4] for i in range(0, len(self.iban), 4)])
+
+
+@dataclass
+class Transaction:
+    """Bank transaction"""
+    transaction_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    reference: str = field(default_factory=lambda: f"TXN{datetime.now().strftime('%Y%m%d%H%M%S')}{uuid.uuid4().hex[:6].upper()}")
+    transaction_type: TransactionType = TransactionType.CREDIT
+    amount: Decimal = Decimal("0.00")
+    currency: Currency = Currency.EUR
+
+    # Accounts
+    from_iban: Optional[str] = None
+    to_iban: Optional[str] = None
+    account_iban: str = ""  # The account this transaction belongs to
+
+    # Details
+    label: str = ""
+    description: str = ""
+    category: str = ""
+
+    # Counterparty
+    counterparty_name: str = ""
+    counterparty_iban: Optional[str] = None
+    counterparty_bic: Optional[str] = None
+
+    # Metadata
+    status: str = "completed"  # pending, completed, failed, cancelled
+    created_at: datetime = field(default_factory=datetime.now)
+    executed_at: Optional[datetime] = None
+    value_date: Optional[datetime] = None
+
+    # SEPA specific
+    end_to_end_id: Optional[str] = None
+    mandate_id: Optional[str] = None
+
+    # Balance after transaction
+    balance_after: Optional[Decimal] = None
+
+    def __post_init__(self):
+        if not self.end_to_end_id:
+            self.end_to_end_id = self.reference
+        if not self.executed_at:
+            self.executed_at = self.created_at
+        if not self.value_date:
+            self.value_date = self.created_at
+
+    @property
+    def is_credit(self) -> bool:
+        return self.transaction_type in [
+            TransactionType.CREDIT,
+            TransactionType.SEPA_CREDIT,
+            TransactionType.REFUND,
+            TransactionType.INTEREST,
+        ]
+
+    @property
+    def is_debit(self) -> bool:
+        return not self.is_credit
+
+    @property
+    def signed_amount(self) -> Decimal:
+        """Return amount with sign (positive for credit, negative for debit)"""
+        return self.amount if self.is_credit else -self.amount
+
+    def to_dict(self) -> dict:
+        return {
+            "transaction_id": self.transaction_id,
+            "reference": self.reference,
+            "transaction_type": self.transaction_type.value,
+            "amount": str(self.amount),
+            "signed_amount": str(self.signed_amount),
+            "currency": self.currency.value,
+            "from_iban": self.from_iban,
+            "to_iban": self.to_iban,
+            "account_iban": self.account_iban,
+            "label": self.label,
+            "description": self.description,
+            "category": self.category,
+            "counterparty_name": self.counterparty_name,
+            "counterparty_iban": self.counterparty_iban,
+            "counterparty_bic": self.counterparty_bic,
+            "status": self.status,
+            "created_at": self.created_at.isoformat(),
+            "executed_at": self.executed_at.isoformat() if self.executed_at else None,
+            "value_date": self.value_date.isoformat() if self.value_date else None,
+            "end_to_end_id": self.end_to_end_id,
+            "mandate_id": self.mandate_id,
+            "balance_after": str(self.balance_after) if self.balance_after else None,
+            "is_credit": self.is_credit,
+            "is_debit": self.is_debit,
+        }
+
+
+@dataclass
+class Card:
+    """Bank card"""
+    card_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    card_number: str = ""  # Last 4 digits only for display
+    card_type: str = "visa"  # visa, mastercard
+    expiry_month: int = 12
+    expiry_year: int = 2027
+    status: str = "active"  # active, blocked, expired
+    account_iban: str = ""
+    daily_limit: Decimal = Decimal("1000.00")
+    monthly_limit: Decimal = Decimal("5000.00")
+    contactless_enabled: bool = True
+    online_payments_enabled: bool = True
+
+    def __post_init__(self):
+        if not self.card_number:
+            # Generate last 4 digits
+            self.card_number = f"**** **** **** {uuid.uuid4().int % 10000:04d}"
+
+    @property
+    def expiry(self) -> str:
+        return f"{self.expiry_month:02d}/{self.expiry_year % 100:02d}"
+
+    def to_dict(self) -> dict:
+        return {
+            "card_id": self.card_id,
+            "card_number": self.card_number,
+            "card_type": self.card_type,
+            "expiry": self.expiry,
+            "status": self.status,
+            "account_iban": self.account_iban,
+            "daily_limit": str(self.daily_limit),
+            "monthly_limit": str(self.monthly_limit),
+            "contactless_enabled": self.contactless_enabled,
+            "online_payments_enabled": self.online_payments_enabled,
+        }

nanopy_bank/core/products.py

@@ -0,0 +1,300 @@
+"""
+Banking Products - Loans, Credits, Insurance, Savings
+"""
+
+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 LoanType(Enum):
+    """Types of loans"""
+    PERSONAL = "personal"           # Prêt personnel
+    MORTGAGE = "mortgage"           # Prêt immobilier
+    AUTO = "auto"                   # Crédit auto
+    STUDENT = "student"             # Prêt étudiant
+    BUSINESS = "business"           # Prêt professionnel
+    REVOLVING = "revolving"         # Crédit renouvelable
+
+
+class LoanStatus(Enum):
+    """Loan status"""
+    PENDING = "pending"             # En attente d'approbation
+    APPROVED = "approved"           # Approuvé
+    ACTIVE = "active"               # En cours
+    LATE = "late"                   # En retard
+    DEFAULT = "default"             # Défaut de paiement
+    PAID_OFF = "paid_off"           # Remboursé
+    CANCELLED = "cancelled"         # Annulé
+
+
+class InsuranceType(Enum):
+    """Types of insurance"""
+    LIFE = "life"                   # Assurance vie
+    HOME = "home"                   # Assurance habitation
+    AUTO = "auto"                   # Assurance auto
+    HEALTH = "health"               # Mutuelle santé
+    CREDIT = "credit"               # Assurance emprunteur
+    SAVINGS = "savings"             # Assurance épargne
+
+
+class SavingsType(Enum):
+    """Types of savings products"""
+    LIVRET_A = "livret_a"           # Livret A
+    LDDS = "ldds"                   # Livret Développement Durable
+    LEP = "lep"                     # Livret d'Épargne Populaire
+    PEL = "pel"                     # Plan Épargne Logement
+    CEL = "cel"                     # Compte Épargne Logement
+    TERM_DEPOSIT = "term_deposit"   # Dépôt à terme
+    PEA = "pea"                     # Plan d'Épargne en Actions
+
+
+@dataclass
+class Loan:
+    """
+    Loan / Credit product
+    """
+    loan_id: str = field(default_factory=lambda: f"LN{uuid.uuid4().hex[:10].upper()}")
+    customer_id: str = ""
+    account_iban: str = ""  # Account for repayments
+
+    # Loan details
+    loan_type: LoanType = LoanType.PERSONAL
+    purpose: str = ""  # Description of loan purpose
+
+    # Amounts
+    principal: Decimal = Decimal("0.00")      # Montant emprunté
+    interest_rate: Decimal = Decimal("0.00")  # Taux annuel (ex: 3.5 = 3.5%)
+    total_interest: Decimal = Decimal("0.00") # Total des intérêts
+    total_amount: Decimal = Decimal("0.00")   # Principal + intérêts
+
+    # Current state
+    remaining_principal: Decimal = Decimal("0.00")
+    remaining_interest: Decimal = Decimal("0.00")
+    paid_principal: Decimal = Decimal("0.00")
+    paid_interest: Decimal = Decimal("0.00")
+
+    # Schedule
+    duration_months: int = 12
+    monthly_payment: Decimal = Decimal("0.00")
+    start_date: Optional[date] = None
+    end_date: Optional[date] = None
+    next_payment_date: Optional[date] = None
+
+    # Status
+    status: LoanStatus = LoanStatus.PENDING
+    payments_made: int = 0
+    payments_late: int = 0
+    days_overdue: int = 0
+
+    # Insurance
+    has_insurance: bool = False
+    insurance_premium: Decimal = Decimal("0.00")
+
+    # Collateral (for secured loans)
+    collateral_type: str = ""
+    collateral_value: Decimal = Decimal("0.00")
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+    approved_at: Optional[datetime] = None
+    approved_by: str = ""
+
+    def __post_init__(self):
+        if self.principal > 0 and self.remaining_principal == 0:
+            self.remaining_principal = self.principal
+            self._calculate_loan()
+
+    def _calculate_loan(self):
+        """Calculate loan schedule"""
+        if self.principal <= 0 or self.duration_months <= 0:
+            return
+
+        # Monthly interest rate
+        monthly_rate = self.interest_rate / 100 / 12
+
+        if monthly_rate > 0:
+            # Amortization formula
+            self.monthly_payment = self.principal * (
+                monthly_rate * (1 + monthly_rate) ** self.duration_months
+            ) / ((1 + monthly_rate) ** self.duration_months - 1)
+        else:
+            self.monthly_payment = self.principal / self.duration_months
+
+        self.total_amount = self.monthly_payment * self.duration_months
+        self.total_interest = self.total_amount - self.principal
+        self.remaining_interest = self.total_interest
+
+    def to_dict(self) -> dict:
+        return {
+            "loan_id": self.loan_id,
+            "customer_id": self.customer_id,
+            "account_iban": self.account_iban,
+            "loan_type": self.loan_type.value,
+            "purpose": self.purpose,
+            "principal": str(self.principal),
+            "interest_rate": str(self.interest_rate),
+            "total_interest": str(self.total_interest),
+            "total_amount": str(self.total_amount),
+            "remaining_principal": str(self.remaining_principal),
+            "remaining_interest": str(self.remaining_interest),
+            "paid_principal": str(self.paid_principal),
+            "paid_interest": str(self.paid_interest),
+            "duration_months": self.duration_months,
+            "monthly_payment": str(self.monthly_payment),
+            "start_date": self.start_date.isoformat() if self.start_date else None,
+            "end_date": self.end_date.isoformat() if self.end_date else None,
+            "next_payment_date": self.next_payment_date.isoformat() if self.next_payment_date else None,
+            "status": self.status.value,
+            "payments_made": self.payments_made,
+            "payments_late": self.payments_late,
+            "days_overdue": self.days_overdue,
+            "has_insurance": self.has_insurance,
+            "insurance_premium": str(self.insurance_premium),
+            "collateral_type": self.collateral_type,
+            "collateral_value": str(self.collateral_value),
+            "created_at": self.created_at.isoformat(),
+            "approved_at": self.approved_at.isoformat() if self.approved_at else None,
+            "approved_by": self.approved_by,
+            "progress_percent": self.progress_percent,
+        }
+
+    @property
+    def progress_percent(self) -> float:
+        """Percentage of loan paid off"""
+        if self.total_amount <= 0:
+            return 0
+        paid = self.paid_principal + self.paid_interest
+        return min(100, float(paid / self.total_amount * 100))
+
+
+@dataclass
+class Insurance:
+    """
+    Insurance product
+    """
+    insurance_id: str = field(default_factory=lambda: f"INS{uuid.uuid4().hex[:10].upper()}")
+    customer_id: str = ""
+    policy_number: str = field(default_factory=lambda: f"POL{uuid.uuid4().hex[:8].upper()}")
+
+    # Insurance details
+    insurance_type: InsuranceType = InsuranceType.HOME
+    provider: str = "NanoPy Assurance"
+    product_name: str = ""
+
+    # Coverage
+    coverage_amount: Decimal = Decimal("0.00")
+    deductible: Decimal = Decimal("0.00")  # Franchise
+    coverage_details: str = ""
+
+    # Premium
+    premium_amount: Decimal = Decimal("0.00")
+    premium_frequency: str = "monthly"  # monthly, quarterly, yearly
+    account_iban: str = ""  # For premium payments
+
+    # Dates
+    start_date: date = field(default_factory=date.today)
+    end_date: Optional[date] = None
+    next_payment_date: Optional[date] = None
+
+    # Status
+    status: str = "active"  # active, suspended, cancelled, expired
+    is_auto_renew: bool = True
+
+    # Claims
+    claims_count: int = 0
+    total_claimed: Decimal = Decimal("0.00")
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        return {
+            "insurance_id": self.insurance_id,
+            "customer_id": self.customer_id,
+            "policy_number": self.policy_number,
+            "insurance_type": self.insurance_type.value,
+            "provider": self.provider,
+            "product_name": self.product_name,
+            "coverage_amount": str(self.coverage_amount),
+            "deductible": str(self.deductible),
+            "coverage_details": self.coverage_details,
+            "premium_amount": str(self.premium_amount),
+            "premium_frequency": self.premium_frequency,
+            "account_iban": self.account_iban,
+            "start_date": self.start_date.isoformat(),
+            "end_date": self.end_date.isoformat() if self.end_date else None,
+            "next_payment_date": self.next_payment_date.isoformat() if self.next_payment_date else None,
+            "status": self.status,
+            "is_auto_renew": self.is_auto_renew,
+            "claims_count": self.claims_count,
+            "total_claimed": str(self.total_claimed),
+            "created_at": self.created_at.isoformat(),
+        }
+
+
+@dataclass
+class SavingsProduct:
+    """
+    Savings product (Livret A, PEL, etc.)
+    """
+    savings_id: str = field(default_factory=lambda: f"SAV{uuid.uuid4().hex[:10].upper()}")
+    customer_id: str = ""
+    account_iban: str = ""  # The savings account
+
+    # Product details
+    savings_type: SavingsType = SavingsType.LIVRET_A
+    product_name: str = ""
+
+    # Interest
+    interest_rate: Decimal = Decimal("3.00")  # Current rate
+    interest_frequency: str = "yearly"  # When interest is paid
+    interest_earned: Decimal = Decimal("0.00")
+    last_interest_date: Optional[date] = None
+
+    # Limits
+    min_balance: Decimal = Decimal("0.00")
+    max_balance: Decimal = Decimal("22950.00")  # Livret A ceiling
+    min_deposit: Decimal = Decimal("10.00")
+    max_withdrawal_per_month: Optional[Decimal] = None
+
+    # Tax
+    is_tax_exempt: bool = True  # Livret A, LDDS are tax-free
+    tax_rate: Decimal = Decimal("0.00")  # Flat tax rate if applicable
+
+    # Status
+    status: str = "active"
+    opened_date: date = field(default_factory=date.today)
+    closed_date: Optional[date] = None
+
+    # Metadata
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        return {
+            "savings_id": self.savings_id,
+            "customer_id": self.customer_id,
+            "account_iban": self.account_iban,
+            "savings_type": self.savings_type.value,
+            "product_name": self.product_name,
+            "interest_rate": str(self.interest_rate),
+            "interest_frequency": self.interest_frequency,
+            "interest_earned": str(self.interest_earned),
+            "last_interest_date": self.last_interest_date.isoformat() if self.last_interest_date else None,
+            "min_balance": str(self.min_balance),
+            "max_balance": str(self.max_balance),
+            "min_deposit": str(self.min_deposit),
+            "max_withdrawal_per_month": str(self.max_withdrawal_per_month) if self.max_withdrawal_per_month else None,
+            "is_tax_exempt": self.is_tax_exempt,
+            "tax_rate": str(self.tax_rate),
+            "status": self.status,
+            "opened_date": self.opened_date.isoformat(),
+            "closed_date": self.closed_date.isoformat() if self.closed_date else None,
+            "created_at": self.created_at.isoformat(),
+        }
+
+
+# Note: Demo savings products are in nanopy_bank/data/demo.py

nanopy_bank/data/__init__.py

@@ -0,0 +1,31 @@
+"""
+Data module - Test and demo data
+"""
+
+from .demo import (
+    create_demo_bank,
+    DEMO_CUSTOMERS,
+    DEMO_ACCOUNTS,
+    DEMO_TRANSACTIONS,
+    DEMO_CARDS,
+    DEMO_BENEFICIARIES,
+    DEMO_STANDING_ORDERS,
+    DEMO_FEES,
+    DEMO_RATES,
+    DEMO_BRANCHES,
+    DEMO_EMPLOYEES,
+)
+
+__all__ = [
+    "create_demo_bank",
+    "DEMO_CUSTOMERS",
+    "DEMO_ACCOUNTS",
+    "DEMO_TRANSACTIONS",
+    "DEMO_CARDS",
+    "DEMO_BENEFICIARIES",
+    "DEMO_STANDING_ORDERS",
+    "DEMO_FEES",
+    "DEMO_RATES",
+    "DEMO_BRANCHES",
+    "DEMO_EMPLOYEES",
+]