Python has a concept called Decorator [1] which is a function that takes another function and extends the behavior. In the following script, the timeit decorator is used to measure the execution time of the heavy_computation function:

  import time
  from functools import wraps

  def timeit(text):
      def deco(target):
          @wraps(target)
          def wrapper(*args, **kwargs):
              # execute and measure the target run time
              start_time = time.perf_counter()
              result = target(*args, **kwargs)
              total_time = time.perf_counter() - start_time
              # print elapsed time
              print(text.format(total=total_time))
              return result
          return wrapper
      return deco

  @timeit(text="Done in {total:.3f} seconds !")
  def heavy_computation(a, b):
      time.sleep(2)  # doing some heavy computation !
      return a*b

  if __name__ == "__main__":
      result = heavy_computation(6, 9)
      print("Result:", result)

  $ python -m test
  Done in 2.001 seconds !
  Result: 54
  

While decorators are cool, it's worth mentioning that using a decorator is much more intuitive than writing its code. The code is entirely different depending on whether the decorator takes arguments or not.

The following code performs the same task as the previous one, except it is more clear and intuitive:

  import time
  from hooking import on_enter

  def timeit(context, *args, **kwargs):
      # execute and measure the target run time
      start_time = time.perf_counter()
      context.result = context.target(*args, **kwargs)
      total_time = time.perf_counter() - start_time
      # print elapsed time
      text = context.config.get("text")  # get 'text' from config data
      print(text.format(total=total_time))
      context.target = None

  @on_enter(timeit, text="Done in {total:.3f} seconds !")
  def heavy_computation(a, b):
      time.sleep(2)  # doing some heavy computation !
      return a*b

  if __name__ == "__main__":
      result = heavy_computation(6, 9)
      print("Result:", result)

  $ python -m test
  Done in 2.001 seconds !
  Result: 54

Also, it is a dual paradigm hooking mechanism since it supports tight and loose coupling [5]. The previous code uses the tight coupling paradigm, that's why the timeit hook is directly tied to the target function.

In loose coupling paradigm, targets functions and methods are tagged using a decorator, and hooks are bound to these tags. So when a target is called, the bound hooks are executed upstream or downstream. This paradigm is served by a class designed for pragmatic access via class methods [6]. This class can be easily subclassed to group tags by theme for example.

Here is an example of the loose coupling paradigm:

  import time
  from hooking import H

  @H.tag
  def heavy_computation(a, b):
      print("heavy computation...")
      time.sleep(2)  # doing some heavy computation !
      return a*b

  def upstream_hook(context, *args, **kwargs):
      print("upstream hook...")

  def downstream_hook(context, *args, **kwargs):
      print("downstream hook...")

  # bind upstream_hook and downstream_hook to the "heavy_computation" tag
  H.wrap("heavy_computation", upstream_hook, downstream_hook)

  if __name__ == "__main__":
      result = heavy_computation(6, 9)
      print("Result:", result)

  $ python -m test
  upstream hook...
  heavy computation...
  downstream hook...
  Result: 54

[1] https://peps.python.org/pep-0318/

[2] https://hackersandslackers.com/flask-routes/

[3] http://bottlepy.org/docs/dev/

[4] https://en.wikipedia.org/wiki/Hooking

[5] https://en.wikipedia.org/wiki/Coupling_(computer_programming...

[6] https://stackoverflow.com/a/38276

[7] https://github.com/pyrustic/hooking#examples

[8] http://sl4.org/crocker.html