class Vehicle:
    def __init__(self, make, model):
        self.make  = make
        self.model = model

    def describe(self):
        return f"{self.make} {self.model}"

class Car(Vehicle):
    def __init__(self, make, model, seats):
        super().__init__(make, model)   # reuse Vehicle's setup
        self.seats = seats

    def describe(self):
        base = super().describe()        # extend, don't duplicate
        return f"{base} ({self.seats}-seater)"

my_car = Car("Toyota", "Innova", 7)
print(my_car.describe())
print(isinstance(my_car, Vehicle))   # True — a Car IS-A Vehicle

class BankAccount:
    def __init__(self, owner, balance, pin):
        self.owner    = owner            # public
        self._balance = balance          # protected — internal bookkeeping
        self.__pin    = pin              # private — name-mangled

    def withdraw(self, amount, pin):
        if pin != self.__pin:
            raise PermissionError("Incorrect PIN")
        if amount > self._balance:
            raise ValueError("Insufficient funds")
        self._balance -= amount
        return self._balance

acc = BankAccount("Priya", 5000, pin="4477")
print(acc.withdraw(1200, "4477"))
print(acc._balance)                    # accessible, but a convention violation
print(acc._BankAccount__pin)           # the mangled name — works, but ugly on purpose

class Money:
    def __init__(self, amount, currency="INR"):
        self.amount   = amount
        self.currency = currency

    def __repr__(self):
        return f"Money({self.amount}, {self.currency!r})"   # unambiguous, for debugging

    def __str__(self):
        return f"{self.currency} {self.amount:.2f}"            # friendly, for print()

    def __eq__(self, other):
        return (self.amount, self.currency) == (other.amount, other.currency)

    def __lt__(self, other):
        return self.amount < other.amount

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

salary  = Money(75000)
bonus   = Money(12000)
total   = salary + bonus

print(total)                          # uses __str__
print(repr(total))                    # uses __repr__
print(salary == Money(75000))          # uses __eq__
print(sorted([salary, bonus, total]))  # uses __lt__

class Pizza:
    def __init__(self, size, toppings):
        self.size     = size
        self.toppings = toppings

    def __repr__(self):
        return f"Pizza({self.size}\", {self.toppings})"

    @classmethod
    def margherita(cls, size=12):
        """Alternative constructor — a preset pizza."""
        return cls(size, ["tomato", "mozzarella", "basil"])

    @staticmethod
    def is_valid_size(size):
        """Utility check — doesn't need self or cls."""
        return size in (8, 10, 12, 14, 16)

custom = Pizza(14, ["pepperoni", "olives"])
preset = Pizza.margherita()             # built via the classmethod, no direct __init__ call

print(custom)
print(preset)
print(Pizza.is_valid_size(14))         # called on the class, not an instance
print(Pizza.is_valid_size(13))

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius             # stored internally

    @property
    def celsius(self):
        """Getter — runs when you READ .celsius"""
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        """Setter — runs when you WRITE to .celsius"""
        if value < -273.15:
            raise ValueError("Temperature below absolute zero is impossible")
        self._celsius = value

    @property
    def fahrenheit(self):
        """Read-only computed property — no setter defined"""
        return (self._celsius * 9/5) + 32

t = Temperature(25)
print(t.celsius, t.fahrenheit)     # reads like plain attributes

t.celsius = 30                    # goes through the setter's validation
print(t.celsius, t.fahrenheit)

try:
    t.celsius = -300               # triggers the validation error
except ValueError as e:
    print(f"Rejected: {e}")

import math

class Shape:
    def area(self):
        raise NotImplementedError

    def describe(self):
        # same method name, but behaviour depends on which subclass calls area()
        return f"{type(self).__name__}: area = {self.area():.2f}"

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width, self.height = width, height

    def area(self):
        return self.width * self.height

shapes = [Circle(4), Rectangle(3, 5), Circle(1.5)]

for shape in shapes:
    print(shape.describe())   # one call site, different behaviour per object

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def pay(self, amount):
        """Every subclass MUST implement this."""
        ...

    def receipt(self, amount):
        # concrete methods are still allowed and inherited normally
        return f"Charged ₹{amount} via {type(self).__name__}"

class CreditCardProcessor(PaymentProcessor):
    def pay(self, amount):
        return f"₹{amount} charged to credit card"

class UPIProcessor(PaymentProcessor):
    def pay(self, amount):
        return f"₹{amount} debited via UPI"

processors = [CreditCardProcessor(), UPIProcessor()]
for p in processors:
    print(p.pay(1500))
    print(p.receipt(1500))

# Trying to instantiate the abstract class directly fails immediately:
processor = PaymentProcessor()

from functools import singledispatchmethod

class Invoice:
    def __init__(self):
        self.items = []

    # Approach 1: default arguments cover the common "overload" cases
    def add_item(self, name, qty=1, price=0.0):
        self.items.append((name, qty, price))
        return f"Added {qty} x {name} @ ₹{price}"

    # Approach 2: dispatch on the TYPE of the first real argument
    @singledispatchmethod
    def apply_discount(self, value):
        raise TypeError(f"Unsupported discount type: {type(value).__name__}")

    @apply_discount.register
    def _(self, value: int):
        return f"Flat discount of ₹{value} applied"

    @apply_discount.register
    def _(self, value: float):
        return f"Percentage discount of {value}% applied"

inv = Invoice()
print(inv.add_item("Notebook"))                 # uses both defaults
print(inv.add_item("Pen", qty=5))
print(inv.add_item("Laptop", qty=1, price=55000))

print(inv.apply_discount(200))       # int → flat discount
print(inv.apply_discount(10.0))      # float → percentage discount

class Base:
    def greet(self):
        return "Hello from Base"

class Left(Base):
    def greet(self):
        return f"Hello from Left, then: {super().greet()}"

class Right(Base):
    def greet(self):
        return f"Hello from Right, then: {super().greet()}"

class Child(Left, Right):
    pass   # doesn't define greet() itself — resolution follows the MRO

c = Child()
print(c.greet())
print([cls.__name__ for cls in Child.__mro__])

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return f"Engine roaring at {self.horsepower}hp"

class Car:
    def __init__(self, model, engine):
        self.model  = model
        self.engine = engine          # composed, not inherited — Car HAS-A Engine

    def start(self):
        return f"{self.model}: {self.engine.start()}"

petrol_engine = Engine(150)
electric_engine = Engine(300)

car1 = Car("Sedan", petrol_engine)
car2 = Car("EV Hatchback", electric_engine)

print(car1.start())
print(car2.start())