How to implement saga orchestration with compensating steps in Python

class InventoryService:
    def reserve(self, order_id):
        print(f"[Inventory] Reserving stock for order {order_id}")
        return True

    def compensate(self, order_id):
        print(f"[Inventory] Releasing stock for order {order_id}")


class PaymentService:
    def charge(self, order_id):
        print(f"[Payment] Charging customer for order {order_id}")
        return True

    def compensate(self, order_id):
        print(f"[Payment] Refunding customer for order {order_id}")


class ShippingService:
    def ship(self, order_id):
        print(f"[Shipping] Shipping order {order_id}")
        return True

    def compensate(self, order_id):
        print(f"[Shipping] Canceling shipment for order {order_id}")


def place_order(order_id):
    inventory = InventoryService()
    payment = PaymentService()
    shipping = ShippingService()

    steps = [
        ("reserve inventory", lambda: inventory.reserve(order_id), lambda: inventory.compensate(order_id)),
        ("charge payment", lambda: payment.charge(order_id), lambda: payment.compensate(order_id)),
        ("ship order", lambda: shipping.ship(order_id), lambda: shipping.compensate(order_id)),
    ]

    executed = []

    for step_name, action, compensate in steps:
        print(f"Executing: {step_name}")
        if not action():
            print(f"FAILED at: {step_name}")
            print("Starting compensation...")
            for executed_name, executed_compensate in reversed(executed):
                print(f"Compensating: {executed_name}")
                executed_compensate()
            return False
        executed.append((step_name, compensate))

    print("Order placed successfully!")
    return True


if __name__ == "__main__":
    # Simulate a successful flow
    place_order("ORD-123")
    print("-" * 40)
    # Simulate a failure during payment
    PaymentService.charge = lambda self, order_id: False  # monkey-patch to fail
    place_order("ORD-456")