Time a method of an object

Question

I have the following situation : I want to time a method for multiple objects :

class Foo():
  def method(self):
    pass
class Bar():
  def method(self, x):
    print(x)

More specifically, I want to have a list that gets appended with the execution time every time the method is called.

So basically, I want to have a function time_method such that the following code will print the time of 3 executions of the method method for the x object.

x = Foo()
y = time_method(x, 'method')
for i in range(3):
  y.method()
print(y.get_time())

So basically y would need to act exactly like x everywhere except when y.method() is called in which case it would also record the time of execution. The list of time of execution could then be accessed by the get_time method specific to y. This time_method function should work on any object.

Answer 1

I think this should work:

import inspect

class time_method:
    def __init__(self,timedClass,method):
        self.timedClass = timedClass
        self.methodName = method
        self.measuredTimes = []
        self.all_methods = inspect.getmembers(timedClass, predicate=inspect.ismethod)
        self.set_all_methods();
        setattr(self, method, self.timeMethod)

    def timeMethod(self,*args,**kwargs):
        start = time.time()
        res=getattr(self.timedClass, self.methodName)(*args,**kwargs)
        end = time.time()
        self.measuredTimes.append(end-start)
        return res

    def get_time(self):
        return self.measuredTimes

    def set_all_methods(self):
        for method in self.all_methods:
            setattr(self, *method)

    def __getitem__(self,*args,**kwargs):
        return self.timeMethod(*args,**kwargs)

    def __repr__(self,*args,**kwargs):
        return self.timeMethod(*args,**kwargs)

All special functions that are supposed to work must be implemented in the pattern shown above. Of course, when initialising time_method one has to say:

y = time_method(x, '__getitem__')

Then you can call as:

y[something]

Answer 2

After some trial and errors, this seems to be working :

import types
import time

def time_method(x, method):
    setattr(x, f'time_of_{method}', [])
    if method not in get_object_methods(x):
        print(f'Object {x} doesn\'t have method {method}')
    else:
        old_method = getattr(x, method)
        def new_method(self, *args, **kwargs):
            start = time.time()
            res = old_method(*args, **kwargs) 
            end = time.time()
            getattr(x, f'time_of_{method}').append(end-start)
            return res
        setattr(x, method, types.MethodType(new_method, x))
    return x

The only 'issue' is that it modifies x in place but it shouldn't be a problem in my use case.

Note : This doesn't work for method that are bound to the class like __getitem__ Is it possible to override __getitem__ at instance level in Python?

Note 2 : With multiprocessing, things get a little more tricky, indeed, if your object is sent to multiple thread the f'time_of_{method}' attribute is not shared and essentially never update. A solution is to use Manager

import multiprocessing
manager = multiprocessing.Manager()

And to replace [] by manager.list() at initialization.