PyInns - Home

Renaming Decorated Functions with Dask in Python 2026 – Best Practices

When you apply decorators (especially with Dask), the original function name is often replaced by the wrapper name (usually "wrapper"). This makes debugging, logging, and task graph visualization confusing. In 2026, properly renaming decorated functions is considered essential for readable code and clear Dask task graphs.

TL;DR — The Solution

Always use @wraps(func) from functools
This preserves __name__, __doc__, and signature
For custom renaming, use wrapper.__name__ = func.__name__
Clear names make Dask task graphs much more readable

1. The Problem Without Proper Renaming


def timer(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@timer
def process_large_file(file_path):
    """Process a very large file."""
    # ... heavy processing ...
    return "done"

print(process_large_file.__name__)   # "wrapper" ← Confusing!

2. Correct Way – Using `@wraps`


from functools import wraps
import time

def timer(func):
    @wraps(func)                    # ← This is the key
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"⏱️  {func.__name__}() took {elapsed:.4f} seconds")
        return result
    return wrapper

@timer
def process_large_file(file_path):
    """Process a very large file with Dask."""
    # ... heavy Dask processing ...
    return "done"

print(process_large_file.__name__)   # "process_large_file" ✓
print(process_large_file.__doc__)    # Original docstring preserved

3. With Dask `delayed` and Decorators


from dask import delayed
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        import time
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@delayed
@timer
def heavy_computation(n):
    """This is a computationally heavy function."""
    return sum(i**2 for i in range(n))

# The task graph will now show the original name
result = heavy_computation(10_000).compute()

4. Best Practices in 2026

Always use @wraps(func) in every decorator you write
Place @wraps on the innermost wrapper function
When stacking decorators, order matters — apply @wraps at each level if needed
Clear function names make Dask task graphs readable and debugging much easier
For advanced cases, you can manually set wrapper.__name__ = func.__name__

Conclusion

Renaming decorated functions properly using functools.wraps is no longer optional — it is a required best practice in 2026. It ensures that your Dask task graphs, logs, error messages, and debugging tools show meaningful function names instead of generic "wrapper". This small habit greatly improves code readability and maintainability when working with Dask.

Next steps: