Changeset 579 for branches

Timestamp:

10/15/12 10:27:21 (4 years ago)

Author:

mmckerns

Message:

improved TimedMonitor? to use independent Timer class; added test code

Location:

branches/decorate

Files:

• test_timed_monitor.py (added)
• timer.py (modified) (1 diff)

branches/decorate/timer.py

@@ -11 +11 @@
 
 
-class Monitor(object):
+class Timer(object):
     """
-Instances of objects that can be passed as monitors.
-Typically, a Monitor logs a list of parameters and the
-corresponding costs, retrievable by accessing the Monitor's
-member variables.
+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...
-    >>> sow = Monitor()
-    >>> sow([1,2],3)
-    >>> sow([4,5],6)
-    >>> sow.x
-    [[1, 2], [4, 5]]
-    >>> sow.y
-    [3, 6]
-
+    >>> 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):#, all=True):
-        self._x = []
-        self._y = []
-        self._id = []
-        self._info = []
-        self._t = []
+    def __init__(self, **kwds):
+        self.__on = kwds.get('on', False)
+        self.__off = 0
+        self.__t = []
         self.__t0 = [self.__now()]
-        self._timed = kwds.get('timed', False)
-       #self._all = all
-
-    def __len__(self):
-        return len(self.x)
-
-    def info(self, message):
-        self._info.append("%s" % "".join(["",str(message)]))
-        return
-
-    def timer(self, on='?'): #XXX: str-driven args... a hallmark of bad design
-        if on == '?':
-            return self._timed
-        if on in [False, None, 'off']: #turn timing off
-            self._timed = False
-        elif isinstance(on, bool) or on == 'on': #turn timing on
-            self._timed = True
-        elif on == 'toggle': #toggle timing
-            self._timed = not self._timed
-        elif on in ['reset', 'restart']: #'restart' the StartTime
-            self.__t0.append(self.__now())
-        return
-
+        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] * (len(self._y) - len(self._t))
+        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):
-        if self._timed:
-            self._t.extend(self.__deadtime())
-            self._t.append(self.__now())
-        from mystic.tools import listify
-        self._x.append(listify(x)) #XXX: better to save as-is?
-        self._y.append(listify(y)) #XXX: better to save as-is?
-        self._id.append(id)
-       #if not self._all and list_or_tuple_or_ndarray(x):
-       #    self._x[-1] = self._x[-1][best]
-       #if not self._all and list_or_tuple_or_ndarray(y):
-       #    self._y[-1] = self._y[-1][best]
-
-    def get_x(self):
-        return self._x
-
-    def get_y(self):
-        return self._y
-
-    def get_id(self):
-        return self._id
-
-    def get_info(self):
-        return self._info
-
-    def get_t(self):
-        from numpy import array
-        return list(array(self._t + self.__deadtime()) - self._t0)
-
-    def _get_t0(self):
-        return self.__t0[-1]
-
-    def _set_t0(self, t): #XXX: allow setting t0 ?
-        self.__t0.append(t)
+        self.timer()
+        super(TimedMonitor,self).__call__(x, y, id, **kwds)
         return
 
-    x = property(get_x, doc = "Params")
-    y = property(get_y, doc = "Costs")
-    id = property(get_id, doc = "Id")
-    t = property(get_t, doc = "Time")
-    _t0 = property(_get_t0, _set_t0, doc = "StartTime")
     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