How would you write a decorator that accepts arguments (e.g., @retry(times=3))?
A decorator factory: outer function takes parameters and returns the real decorator
To accept arguments you add one more level of nesting. The outermost function takes the decorator parameters and returns the actual decorator; that decorator takes the function and returns the wrapper; the wrapper takes the call arguments and contains the behavior. This is why the call site becomes @retry(times=3) with parentheses: retry(times=3) is evaluated first and produces the decorator that Python then applies to the function. Getting the level count right, and validating the parameters in the outermost scope so a bad configuration fails at import time rather than on the first call, is the practical skill here.
- 1
Three levels: parameters -> decorator(fn) -> wrapper(*args, **kwargs). Forget one level and you get either @retry applied to the function or a TypeError at decoration time.
- 2
Validate parameters in the outermost function so misconfiguration fails fast at import, not on the first invocation.
- 3
Retry specifically needs a bounded attempt count, a backoff with jitter, and a narrow exception tuple. Catching bare Exception hides real bugs and makes incident debugging miserable.
- 4
Trade-off: for anything non-trivial, a battle-tested library such as tenacity or backoff gives you jitter, circuit breaking, and async support for free. Hand-rolled retry decorators are a classic source of retry storms.
- 5
Common mistake: writing @retry instead of @retry() and then wondering why the function is never called with the parameters.
- 6
Version note: functools.wraps works the same at any nesting depth. For async targets you need a separate async def wrapper that awaits the coroutine function; a sync wrapper around a coroutine returns an un-awaited coroutine.
Scenario Questions
0-2 years experience
- 1Why does @retry(times=3) need an extra pair of parentheses compared to @retry?
- 2What does the outermost function of a parameterized decorator actually return?
2-5 years experience
- 1Your retry decorator catches every exception and hides a real bug for weeks. How do you fix the exception handling?
- 2You want invalid decorator parameters to fail at import time. Where do you put the validation and why?
5-8 years experience
- 1You need retries with exponential backoff, jitter, and a circuit breaker. How do you structure this without a giant nested decorator?
- 2You need identical retry semantics for async functions. What changes in the wrapper, and what breaks if you forget?
8+ years experience
- 1Design a retry policy layer shared across many services that is idempotency-aware and emits observability data per attempt.
- 2Your parameterized decorator must stay introspectable and type-check cleanly under mypy. How do you annotate the factory and the wrapper?
Follow-up Questions
- Why does @retry require parentheses while @retry(times=3) does not look like a decorator at all?
- How would you add async support to this retry decorator without duplicating the logic?