No. Our wrapper increments only after a successful return.

A decorator preserves an interface and layers behavior around a collaborator. Wrappers can be composed, but their order matters: logging outside a retry wrapper sees one logical request, while logging inside it sees each attempt. This example deliberately counts accepted calls, not actual message delivery beyond the sender’s contract.

What the function promises: CountingSender exposes send and increments successes only when the wrapped sender returns normally.

class CountingSender:
    def __init__(self, inner):
        self.inner = inner
        self.successes = 0
    def send(self, message):
        self.inner.send(message)
        self.successes += 1

class LocalSender:
    def __init__(self):
        self.messages = []
    def send(self, message):
        if not message:
            raise ValueError("Empty message")
        self.messages.append(message)

wrapped = CountingSender(LocalSender())
wrapped.send("hello")
assert wrapped.successes == 1
try:
    wrapped.send("")
except ValueError:
    pass
assert wrapped.successes == 1

Work and storage: O(1) added work per wrapper; a stack of k wrappers adds O(k) call overhead.

When to recognize it: Counting after delegation records successes. Counting before it records attempts. Decide which metric you promised.

Check before applying it: Wrapper order affects observable behavior. Do not assume two decorators commute.

A protection proxy emphasizes controlling access. Decorator and proxy can look similar in code; distinguish their intent and contract.