Saving the arguments of a function each time it is called, using a decorator defined in a parent class

You could write a decorator for initialize, but this would mean that users who wish to override initialize in their subclass must also use the decorator. If they don’t, their implementation will not call your save_last_arginfo method.

If you want to get around this problem, you can define __init_subclass__ on your base class and perform the decoration for initialize there. That way the decorator is applied to each subclass’ initialize method and users don’t even need to know about the existence of your decorator.

To simplify a bit, I am just going to show how to store the args and kwargs for the last initialize call, and not do extensive introspection. Here is a simplified example of what you described with my suggested approach:

from collections.abc import Callable
from functools import wraps
from typing import Concatenate, ParamSpec, TypeVar


P = ParamSpec("P")
R = TypeVar("R")
T = TypeVar("T", bound="A")


class A:
    last_args: tuple[object, ...]
    last_kwargs: dict[str, object]

    @staticmethod
    def save_last_method_call(
        unbound_method: Callable[Concatenate[T, P], R]
    ) -> Callable[Concatenate[T, P], R]:
        @wraps(unbound_method)
        def wrapper(self: T, /, *args: P.args, **kwargs: P.kwargs) -> R:
            self.last_args = args
            self.last_kwargs = kwargs
            return unbound_method(self, *args, **kwargs)
        return wrapper

    @classmethod
    def __init_subclass__(cls, **_kwargs: object) -> None:
        setattr(cls, "initialize", cls.save_last_method_call(cls.initialize))

    def initialize(self, a: int, b: int = 1) -> None:
        pass

On the user’s side, we could have this:

class Z(A):
    def initialize(self, a: int, b: int = 1, c: int = 2, **kwargs: int) -> None:
        pass


def main() -> None:
    z = Z()
    z.initialize(0, b=3, c=8, d=12)
    args = z.last_args
    kwargs = z.last_kwargs
    print(f"initialize({args=}, {kwargs=})")


if __name__ == "__main__":
    main()

Output:

initialize(args=(0,), kwargs={'b': 3, 'c': 8, 'd': 12})

---

I think it makes sense to define the decorator as a staticmethod because on the one hand the class itself is not really needed, but on the other hand it relies on self inside the wrapper to be an instance of A. Therefore the method is intimately related to the A base class.

One advantage of this setup is that you can very easily apply this decorator to any other method of any subclass of A or even to all of them, if you want to. If you do that inside __init_subclass__, it guarantees the decoration of those methods for every subclass. (Unless of course a user overrides __init_subclass__ himself and does not call the parent’s method.)

What exactly you want to do inside save_last_method_call is ultimately up to you. This just demonstrates the concept of applying the decorator automatically. If you want to do more inspection there, I don’t really see an issue with that.

---

In my code I used type annotations, which pass mypy --strict cecks. But for ParamSpec and Concatenate to be supported, you need Python 3.10+. If you are on an earlier version, it might be enough to simply change the typing imports to this:

...
from typing import TypeVar
from typing_extensions import Concatenate, ParamSpec