OOP: Class, Inheritance, Dataclass

class BankAccount:
    """একটা সাধারণ bank account।"""

    bank_name = "Demo Bank"            # class attribute: সব account এর জন্য এক

    def __init__(self, owner: str, balance: int = 0) -> None:
        self.owner = owner             # instance attribute: প্রতিটা account এর আলাদা
        self.balance = balance

    def deposit(self, amount: int) -> None:
        if amount <= 0:
            raise ValueError("টাকার পরিমাণ শূন্যের বেশি হতে হবে")
        self.balance += amount

    def withdraw(self, amount: int) -> None:
        if amount > self.balance:
            raise ValueError("পর্যাপ্ত টাকা নেই")
        self.balance -= amount


acc = BankAccount("Rahim", 1000)
acc.deposit(500)
acc.withdraw(200)
print(acc.owner, acc.balance)      # Rahim 1300
print(acc.bank_name)               # Demo Bank

class Rectangle:
    def __init__(self, width: float, height: float) -> None:
        self.width = width
        self.height = height

    @property
    def area(self) -> float:          # method, কিন্তু attribute এর মতো পড়া যায়
        return self.width * self.height

r = Rectangle(4, 5)
print(r.area)       # 20  ← r.area() না

class Product:
    def __init__(self, name: str, price: int) -> None:
        self.name = name
        self.price = price            # এটাও নিচের setter দিয়ে যাবে

    @property
    def price(self) -> int:
        return self._price

    @price.setter
    def price(self, value: int) -> None:
        if value < 0:
            raise ValueError("দাম ঋণাত্মক হতে পারে না")
        self._price = value

p = Product("Mouse", 650)
p.price = -10       # ValueError

class Money:
    def __init__(self, paisa: int) -> None:
        self.paisa = paisa

    def __repr__(self) -> str:                 # debug এ কীভাবে দেখাবে
        return f"Money({self.paisa})"

    def __str__(self) -> str:                  # print() এ কীভাবে দেখাবে
        return f"৳{self.paisa / 100:,.2f}"

    def __add__(self, other: "Money") -> "Money":   # a + b
        return Money(self.paisa + other.paisa)

    def __eq__(self, other: object) -> bool:   # a == b
        return isinstance(other, Money) and self.paisa == other.paisa

    def __lt__(self, other: "Money") -> bool:  # a < b (sort এর জন্য)
        return self.paisa < other.paisa


a = Money(12550)
b = Money(4500)
print(a + b)               # ৳170.50
print(repr(a))             # Money(12550)
print(sorted([a, b]))      # [Money(4500), Money(12550)]

from dataclasses import dataclass, field
from datetime import datetime


@dataclass
class OrderItem:
    name: str
    price: int          # পয়সায়
    qty: int = 1

    @property
    def subtotal(self) -> int:
        return self.price * self.qty


@dataclass
class Order:
    id: int
    customer: str
    items: list[OrderItem] = field(default_factory=list)   # mutable default এর সঠিক উপায়
    created_at: datetime = field(default_factory=datetime.now)

    def add(self, item: OrderItem) -> None:
        self.items.append(item)

    @property
    def total(self) -> int:
        return sum(i.subtotal for i in self.items)


order = Order(id=1, customer="Nila")
order.add(OrderItem("Burger", 25000, 2))
order.add(OrderItem("Coke", 4000))
print(order)            # সুন্দর repr নিজে থেকেই
print(order.total)      # 54000

@dataclass(frozen=True)          # বদলানো যাবে না (immutable), hashable হয়
class Location:
    lat: float
    lng: float

@dataclass(order=True)           # <, > দিয়ে তুলনা করা যাবে
class Version:
    major: int
    minor: int

@dataclass(slots=True)           # কম memory, attribute এর বানান ভুল করলে error
class Point:
    x: int
    y: int

from enum import StrEnum

class OrderStatus(StrEnum):
    PENDING = "pending"
    CONFIRMED = "confirmed"
    ON_THE_WAY = "on_the_way"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"

status = OrderStatus.CONFIRMED
print(status == "confirmed")          # True, StrEnum string এর সাথে তুলনা করা যায়
print([s.value for s in OrderStatus])

class PaymentMethod:
    def __init__(self, amount: int) -> None:
        self.amount = amount

    def pay(self) -> str:
        raise NotImplementedError("প্রতিটা payment method নিজের pay() লিখবে")

    def receipt(self) -> str:
        return f"{self.amount / 100:.2f} টাকা পরিশোধ: {self.pay()}"


class MobileWallet(PaymentMethod):
    def __init__(self, amount: int, phone: str) -> None:
        super().__init__(amount)          # parent এর __init__
        self.phone = phone

    def pay(self) -> str:
        return f"wallet {self.phone} থেকে"


class Card(PaymentMethod):
    def __init__(self, amount: int, last4: str) -> None:
        super().__init__(amount)
        self.last4 = last4

    def pay(self) -> str:
        return f"card ****{self.last4} থেকে"


class CashOnDelivery(PaymentMethod):
    def pay(self) -> str:
        return "ডেলিভারির সময় নগদ"


payments: list[PaymentMethod] = [
    MobileWallet(55000, "017xxxxxxxx"),
    Card(120000, "4242"),
    CashOnDelivery(30000),
]
for p in payments:
    print(p.receipt())     # প্রতিটা নিজের pay() চালায়: polymorphism

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def pay(self) -> str: ...

class Broken(PaymentMethod):
    pass

Broken()   # TypeError: Can't instantiate abstract class Broken with abstract method pay

# খারাপ: notification পাঠানোর ক্ষমতার জন্য inheritance
class OrderWithEmail(Order, EmailSender): ...

# ভালো: notification পাঠানোর জিনিসটা বাইরে থেকে দেওয়া
class OrderService:
    def __init__(self, notifier: "Notifier") -> None:
        self.notifier = notifier

    def place(self, order: Order) -> None:
        # ... order save
        self.notifier.send(order.customer, "আপনার order নেওয়া হয়েছে")

from dataclasses import dataclass

@dataclass
class User:
    name: str
    email: str

    @classmethod
    def from_dict(cls, data: dict) -> "User":      # বিকল্প constructor
        return cls(name=data["full_name"], email=data["email"].lower())

    @staticmethod
    def is_valid_email(email: str) -> bool:        # class এর সাথে সম্পর্কিত, কিন্তু object লাগে না
        return "@" in email and "." in email.split("@")[-1]

u = User.from_dict({"full_name": "Sara", "email": "SARA@X.COM"})
print(User.is_valid_email("abc@test.com"))