source: branches/decorate/timer.py @ 855

#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 2012-2016 California Institute of Technology.
# License: 3-clause BSD.  The full license text is available at:
#  - http://mmckerns.github.io/project/mystic/browser/mystic/LICENSE

def timed(verbose=True):
    def dec(f):
        """decorator for timing a function"""
        from time import time as now
        __time = [True, None]
        if not verbose: __time[0] = False
        def time(stamp=False):
            if not stamp: return __time[-1]
            import datetime
            return datetime.timedelta(seconds=__time[-1])
        def __verbose(on=True):
            __time[0] = bool(on)
        def func(*args, **kwds):
            t = now()
            res = f(*args, **kwds)
            __time[-1] = now() - t
            if __time[0]:
                print "Timed: %s" % __time[-1]
            return res
        func.time = time
        func.verbose = __verbose
        return func
    return dec


class Timer(object):
    """
Instances of timer objects that can be passed as timers.
Typically, a timer is attached to a monitor and is called
when the monitor is called.

example usage...
    >>> timer = Timer()
    >>> timer.stamp = False
    >>> timer()
    >>> timer._t
    51.91421914100647
    >>> timer()
    >>> timer._t
    74.009551048278809
    >>> timer.t
    [51.91421914100647, 74.009551048278809]
    >>> timer.stamp = True
    >>> print timer._t
    0:01:14.009551
    >>> print timer.t0
    2012-10-15 13:00:53.758812
    """
    def __init__(self, **kwds):
        self.__on = kwds.get('on', False)
        self.__off = 0
        self.__t = []
        self.__t0 = [self.__now()]
        self.__stamp = kwds.get('stamp', True)
        self.__lazy = kwds.get('lazy', True)
    def __call__(self):
        if self.__on or self.__lazy:
            self.__on = True
            self.__t.extend(self.__deadtime())
            self.__t.append(self.__now())
            self.__off = 0
        else:
            self.__off += 1
    def __get_lazy(self):
        return self.__lazy
    def __set_lazy(self, ind):
        """if True, 'call' will turn timer on"""
        self.__lazy = bool(ind)
    def __get_stamp(self):
        return self.__stamp
    def __set_stamp(self, ind):
        """if True, _t & t0 return datetime object"""
        self.__stamp = bool(ind)
    def __get_on(self):
        return self.__on
    def __set_on(self, ind):
        """if False, record 'nan' instead of a time"""
        self.__on = bool(ind)
    def __toggle(self):
        """toggle the timer on/off"""
        self.__on = not self.__on
    def __reset(self):
        """reset t0 to now"""
        self.__t0.append(self.__now())
        #XXX: should reset to original kwds settings? (on, lazy, ...)
    def __get_t0(self):
        t = self.__t0[-1]
        if not self.__stamp: return t
        import datetime
        return datetime.datetime.fromtimestamp(t)
    def __set_t0(self, t): #XXX: allow setting t0 ?
        self.__t0.append(t)
    def __first(self):
        """get all t0 as a list"""
        return self.__t0
    def __now(self):
        from time import time as now
        return now()  
    def __deadtime(self):
        from numpy import NaN
        return [NaN] * self.__off
    def __get_t(self):
        from numpy import array
        return list(array(self.__t + self.__deadtime()) - self.__t0[-1])
    def __last(self):
        """just get the last t, instead of all t"""
        if not self.__t: return None # require a 'call'
        t = self.__t[-1] - self.__t0[-1]
        if t < 0.0: return None  # require a 'call' after a 'reset'
        if not self.__stamp: return t
        import datetime
        return datetime.timedelta(seconds=t)
    on = property(__get_on, __set_on)
    toggle = property(__toggle)
    reset = property(__reset)
    _t0 = property(__first) # [t0, ...]
    t0 = property(__get_t0,__set_t0) # t0
    _t = property(__last) # t
    t = property(__get_t) # [t, ...]
    stamp = property(__get_stamp, __set_stamp)
    lazy = property(__get_lazy, __set_lazy)


from mystic.monitors import Monitor
class TimedMonitor(Monitor):
    """A timed version of the basic Monitor.

Every time the monitor is called, the time is also logged.
Timer is configurable through 'monitor.timer'.
    """
    def __init__(self, **kwds):#, all=True):
        timed = kwds.pop('timed', False)
       #called = kwds.pop('lazy', True)
       #stamp = kwds.pop('stamp', True)
        super(TimedMonitor,self).__init__(**kwds)
        self.timer = Timer(on=timed)#,lazy=called,stamp=stamp) 
        return

    def __call__(self, x, y, id=None, **kwds):#, best=0):
        self.timer()
        super(TimedMonitor,self).__call__(x, y, id, **kwds)
        return

    pass


if __name__ == '__main__':
    monitor = TimedMonitor()
    monitor.timer.lazy = False
    monitor([1],1)
    monitor.timer.on = True
    monitor([2],2)
    monitor([3],3)
    monitor.timer.toggle
    print "x: %s" % monitor.x
    print "y: %s" % monitor.y
    print "t: %s" % monitor.timer.t
    print "t0: %s" % monitor.timer.t0
    monitor.timer.stamp = False
    print "Ran: %s seconds" % monitor.timer._t
    monitor.timer.stamp = True
    monitor.timer.reset
    monitor([4],4)
    print "x: %s" % monitor.x
    print "y: %s" % monitor.y
    print "t: %s" % monitor.timer.t
    print "t0: %s" % monitor.timer.t0
    monitor.timer.stamp = False
    print "Ran: %s seconds" % monitor.timer._t
    monitor.timer.stamp = True
    monitor.timer.toggle
    monitor([5],5)
    print "x: %s" % monitor.x
    print "y: %s" % monitor.y
    print "t: %s" % monitor.timer.t
    print "t0: %s" % monitor.timer.t0
    monitor.timer.stamp = False
    print "Ran: %s seconds" % monitor.timer._t
    monitor.timer.stamp = True
    print "Completed: %s" % (monitor.timer._t + monitor.timer.t0)

# EOF