Liskov Substitution and Interface Segregation

# --- LSP: classic Rectangle/Square counterexample ---

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

    def set_width(self, width: float) -> None:
        self.width = width

    def set_height(self, height: float) -> None:
        self.height = height

    def area(self) -> float:
        return self.width * self.height


class Square(Rectangle):
    """Violates LSP: forces width == height, breaking Rectangle's contract."""
    def set_width(self, width: float) -> None:
        self.width = width
        self.height = width  # silently changes height too!

    def set_height(self, height: float) -> None:
        self.width = height
        self.height = height  # silently changes width too!


def resize_and_check(rect: Rectangle) -> None:
    rect.set_width(5)
    rect.set_height(10)
    # A caller relying on Rectangle's contract expects area == 50 here.
    assert rect.area() == 50, f"LSP broken: got {rect.area()}"


# resize_and_check(Rectangle(1, 1))  # passes
# resize_and_check(Square(1, 1))     # fails: area is 100, not 50

# LSP-compliant fix: don't force Square to inherit Rectangle's mutable contract.
# Instead, use a shared read-only Shape abstraction.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

class FixedRectangle(Shape):
    def __init__(self, width: float, height: float):
        self._width = width
        self._height = height

    def area(self) -> float:
        return self._width * self._height

class FixedSquare(Shape):
    def __init__(self, side: float):
        self._side = side

    def area(self) -> float:
        return self._side * self._side


# --- ISP: splitting a fat interface into focused ones ---

# Before: one bloated interface forces every worker to implement everything.
class FatWorker(ABC):
    @abstractmethod
    def work(self): ...
    @abstractmethod
    def eat(self): ...
    @abstractmethod
    def sleep(self): ...

class RobotWorker(FatWorker):
    def work(self):
        print("welding")
    def eat(self):
        raise NotImplementedError("robots don't eat")  # forced, unused method
    def sleep(self):
        raise NotImplementedError("robots don't sleep")


# After: smaller, role-specific interfaces.
class Workable(ABC):
    @abstractmethod
    def work(self): ...

class Eatable(ABC):
    @abstractmethod
    def eat(self): ...

class Sleepable(ABC):
    @abstractmethod
    def sleep(self): ...

class HumanWorker(Workable, Eatable, Sleepable):
    def work(self):
        print("coding")
    def eat(self):
        print("eating lunch")
    def sleep(self):
        print("sleeping")

class Robot(Workable):
    def work(self):
        print("welding")