Decorators¶

Legacy Wiki Page

This page was migrated from the old MoinMoin-based wiki. Information may be outdated or no longer applicable. For current documentation, see python.org.

See also PythonDecoratorLibrary. And apart from decorators in the standard library, there are also lots of PyPI packages with convenient, interesting or novel use cases:

Category	Decorator	Summary
builtin	@property	Turn function into property accessor, also: `@property.setter`
builtin	@classsmethod	Use `cls` instead of `self`
builtin	@staticmethod	Defines methods without self handle
stdlib	@functools.wraps	Retain modicum of meta infos (`__doc__`) of wrapped function
stdlib	@functools.singledispatch	Allows for divergent implementations per @f.register()
stdlib/backports	@functools.lru_cache	Wrap computationally expensive functions
stdlib	@functools.cmp_to_key	Transform an old-style comparison function to a key function.
stdlib	@functools.total_ordering	Adds any of the missing lt,le,eq,ge,gt comparison dunder methods
stdlib	@functools.partial	Prepopulate a couple of function arguments
stdlib	@typing.overload	Singledispatch based on function parameter or return types
stdlib	@contextlib.contextmanager	Uses generator protocol `yield` to turn function into `with`-able context mananger
stdlib	@dataclasses.dataclass	Adds various “dunder” methods to the class to streamline property access
stdlib	@atexit.register	Run as shutdown function
stdlib	@abc.ABCMeta.register	Turn into abstract base class
stdlib	@enum.unique	Guarantee unique members in enum class
stdlib	@xmlrpc.register_function	…
stdlib	@sys.settrace	Register function as debugger callback
asyncio	@coroutine	Outdated scheme for `async def`, deprecated in 3.8
asyncio	@throttle(2,1)	Reduce invocations per timeframe
asyncio	@exceptionCatcher…	Log exceptions more instantly
asyncio	@timeit	Basic benchmarking
async	@async_process	make func async and execute in other process
threading	@threaded, @debug, @skip_if_env	Convenient threading wrapper, and testing wrappers
threading	@lock_or_wait	Aquire and release locks for functions
testing	@unittest.mock.patch	Override function w/ signature
testing	@wrapt.patch_function_wrapper	Override function w/ signature
debugging	@trycatch	Capture exceptions to the log
debugging	@log_calls	Record invocations with arguments
decorator	@decorator	Assists declaring signature-preserving and single dispatch decorators
decorator	@decorator_args	Ease parameterizing decorators themselvess
decorator	@named_decorator	Retain callees’ function name to simplify tracebacks
decorator	@dec.decorator(before=cb,after=cb)	Craft trivial enter/exit decorator
decorator	@log_call, @intercept, @instead, @before	Simplifies decorator construnction/interactions, parameter handling
decorator	undecorated(fn)	reversible decoration
collect	@click.option(“-d”)	Argparse alternative
collect	@config_decorator.setting	Declarative dict structure for application settings
collect	@regex_decorator.listen	Register function callbacks for pattern matching
collect	@expose, @register	Plugin interface/registration
typing	@contract({“param”:gt(3)})	Exhaustive function parameter constraints
typing	@pedantic, @trace, @dirty, …	Encourages cleaner and better documented code
typing	@Decorator	OO-style class/method parameters
typing	@mutable, @final, @auto_obj	decorators for str/repr, equality, immutability, and more
typing	@to_string, @data, @repeat	Reduces some common boilerplate for methods
typing	@DataAtrribute(“desc”)	.NET-like attributes
parameter	@curried	Convenient decorator-alternative to partial()
parameter	@attrs	object declarations
parameter	@arg.validate	simplifies parameter handling/assertion
flow handling	@__main__	Automatically run a function if invocation script
flow handling	@retry(times=2)	Reinvokes function a few times when encountering (temporary) exceptions, alt: pypi:retry-decorator
flow handling	@retry	Rerun function in case of exceptions
flow handling	@self	method chaining (fluent interfaces)
monkeypatching	@inject(modules…)	Shorthand assignment to modules/objects
monkeypatching	@monkeybiz.patch(fn)	Swap out function in object, retain reference to original

(Note: Not sure this is going anywhere. Relisting builtins is somewhat redundant, but on topic here. The focus is novel/interesting decorators in the wild. The categorization probably won’t hold up; and probably going to split this up into sections.)

main¶

This decorator does not alter a function, but causes it to be executed if __name__ == '__main__'. This provides an experimental cleaner syntax to the traditional way of bootstrapping a python script. This should not be used on class methods.

The function gets a copied list of sys.argv arguments.

def __main__(func):

   if __name__ == "__main__":
       import sys, os
       args = sys.argv[:]
       args[0] = os.path.abspath(args[0])
       func(args)

📋 Server Request & Proxy Logs

⚙️ Pengaturan Proxy Target

Decorators¶

Other decorator links¶

__main__¶

main¶