Merge pull request #26 from quantopian/change-day-to-trailing-window

Changes EventWindow parameter of days to window length.

tests/test_algorithm.py

@@ -76,5 +76,5 @@ class TestTransformAlgorithm(TestCase):
         assert 'mavg' in algo.registered_transforms
         assert algo.registered_transforms['mavg']['args'] == (['price'],)
         assert algo.registered_transforms['mavg']['kwargs'] == \
-            {'days': 2, 'market_aware': True}
+            {'window_length': 2, 'market_aware': True}
         assert algo.registered_transforms['mavg']['class'] is MovingAverage

zipline/test_algorithms.py

@@ -222,7 +222,7 @@ class TestRegisterTransformAlgorithm(TradingAlgorithm):
     def initialize(self, *args, **kwargs):
         self.add_transform(MovingAverage, 'mavg', ['price'],
                            market_aware=True,
-                           days=2)
+                           window_length=2)
 
         self.set_slippage(FixedSlippage())
 
@@ -251,7 +251,7 @@ def return_args_batch_decorator(data, *args, **kwargs):
 class BatchTransformAlgorithm(TradingAlgorithm):
     def initialize(self, *args, **kwargs):
         self.refresh_period = kwargs.pop('refresh_period', 2)
-        self.days = kwargs.pop('days', 3)
+        self.window_length = kwargs.pop('window_length', 3)
 
         self.args = args
         self.kwargs = kwargs
@@ -265,31 +265,31 @@ class BatchTransformAlgorithm(TradingAlgorithm):
         self.return_price_class = ReturnPriceBatchTransform(
             market_aware=False,
             refresh_period=self.refresh_period,
-            delta=timedelta(days=self.days)
+            delta=timedelta(days=self.window_length)
         )
 
         self.return_price_decorator = return_price_batch_decorator(
             market_aware=False,
             refresh_period=self.refresh_period,
-            delta=timedelta(days=self.days)
+            delta=timedelta(days=self.window_length)
         )
 
         self.return_args_batch = return_args_batch_decorator(
             market_aware=False,
             refresh_period=self.refresh_period,
-            delta=timedelta(days=self.days)
+            delta=timedelta(days=self.window_length)
         )
 
         self.return_price_market_aware = ReturnPriceBatchTransform(
             market_aware=True,
             refresh_period=self.refresh_period,
-            days=self.days
+            window_length=self.window_length
         )
 
         self.return_price_more_days_than_refresh = ReturnPriceBatchTransform(
             market_aware=True,
             refresh_period=1,
-            days=3
+            window_length=3
         )
 
         self.set_slippage(FixedSlippage())

zipline/transforms/mavg.py

@@ -29,22 +29,23 @@ class MovingAverage(object):
     """
     __metaclass__ = TransformMeta
 
-    def __init__(self, fields, market_aware=True, days=None, delta=None):
+    def __init__(self, fields,
+                 market_aware=True, window_length=None, delta=None):
 
         self.fields = fields
         self.market_aware = market_aware
 
         self.delta = delta
-        self.days = days
+        self.window_length = window_length
 
         # Market-aware mode only works with full-day windows.
         if self.market_aware:
-            assert self.days and not self.delta,\
+            assert self.window_length and not self.delta,\
                 "Market-aware mode only works with full-day windows."
 
         # Non-market-aware mode requires a timedelta.
         else:
-            assert self.delta and not self.days, \
+            assert self.delta and not self.window_length, \
                 "Non-market-aware mode requires a timedelta."
 
         # No way to pass arguments to the defaultdict factory, so we
@@ -58,7 +59,7 @@ class MovingAverage(object):
         return MovingAverageEventWindow(
             self.fields,
             self.market_aware,
-            self.days,
+            self.window_length,
             self.delta
         )
 

zipline/transforms/returns.py

@@ -24,8 +24,8 @@ class Returns(object):
     """
     __metaclass__ = TransformMeta
 
-    def __init__(self, days):
-        self.days = days
+    def __init__(self, window_length):
+        self.window_length = window_length
         self.mapping = defaultdict(self._create)
 
     def update(self, event):
@@ -40,7 +40,7 @@ class Returns(object):
         return tracker.returns
 
     def _create(self):
-        return ReturnsFromPriorClose(self.days)
+        return ReturnsFromPriorClose(self.window_length)
 
 
 class ReturnsFromPriorClose(object):
@@ -50,11 +50,11 @@ class ReturnsFromPriorClose(object):
     treat the last event seen  as the close for the previous day.
     """
 
-    def __init__(self, days):
+    def __init__(self, window_length):
         self.closes = deque()
         self.last_event = None
         self.returns = 0.0
-        self.days = days
+        self.window_length = window_length
 
     def update(self, event):
 
@@ -71,7 +71,7 @@ class ReturnsFromPriorClose(object):
                 # if the number of stored events is greater than the
                 # number of days we want to track, the oldest close
                 # is expired and should be discarded.
-                while len(self.closes) > self.days:
+                while len(self.closes) > self.window_length:
                     # Pop the oldest event.
                     self.closes.popleft()
 
@@ -81,7 +81,7 @@ class ReturnsFromPriorClose(object):
         # require giving this transform database creds, which we want
         # to avoid.
 
-        if len(self.closes) == self.days:
+        if len(self.closes) == self.window_length:
             last_close = self.closes[0].price
             change = event.price - last_close
             self.returns = change / last_close

zipline/transforms/stddev.py

@@ -29,21 +29,21 @@ class MovingStandardDev(object):
     """
     __metaclass__ = TransformMeta
 
-    def __init__(self, market_aware=True, days=None, delta=None):
+    def __init__(self, market_aware=True, window_length=None, delta=None):
 
         self.market_aware = market_aware
 
         self.delta = delta
-        self.days = days
+        self.window_length = window_length
 
         # Market-aware mode only works with full-day windows.
         if self.market_aware:
-            assert self.days and not self.delta,\
+            assert self.window_length and not self.delta,\
                 "Market-aware mode only works with full-day windows."
 
         # Non-market-aware mode requires a timedelta.
         else:
-            assert self.delta and not self.days, \
+            assert self.delta and not self.window_length, \
                 "Non-market-aware mode requires a timedelta."
 
         # No way to pass arguments to the defaultdict factory, so we
@@ -56,7 +56,7 @@ class MovingStandardDev(object):
         """
         return MovingStandardDevWindow(
             self.market_aware,
-            self.days,
+            self.window_length,
             self.delta
         )
 

zipline/transforms/utils.py

@@ -193,24 +193,24 @@ class EventWindow(object):
     # Mark this as an abstract base class.
     __metaclass__ = ABCMeta
 
-    def __init__(self, market_aware=True, days=None, delta=None):
+    def __init__(self, market_aware=True, window_length=None, delta=None):
 
         self.market_aware = market_aware
-        self.days = days
+        self.window_length = window_length
         self.delta = delta
 
         self.ticks = deque()
 
         # Market-aware mode only works with full-day windows.
         if self.market_aware:
-            assert self.days and self.delta is None, \
+            assert self.window_length and self.delta is None, \
                 "Market-aware mode only works with full-day windows."
             self.all_holidays = deque(non_trading_days)
             self.cur_holidays = deque()
 
         # Non-market-aware mode requires a timedelta.
         else:
-            assert self.delta and not self.days, \
+            assert self.delta and not self.window_length, \
                 "Non-market-aware mode requires a timedelta."
 
         # Set the behavior for dropping events from the back of the
@@ -285,7 +285,7 @@ class EventWindow(object):
         if oldest.time() > newest.time():
             trading_days_between -= 1
 
-        return trading_days_between >= self.days
+        return trading_days_between >= self.window_length
 
     def out_of_delta(self, oldest, newest):
         return (newest - oldest) >= self.delta
@@ -348,10 +348,11 @@ class BatchTransform(EventWindow):
                  refresh_period=None,
                  market_aware=True,
                  delta=None,
-                 days=None):
+                 window_length=None):
 
         super(BatchTransform, self).__init__(market_aware,
-                                             days=days, delta=delta)
+                                             window_length=window_length,
+                                             delta=delta)
 
         if func is not None:
             self.compute_transform_value = func
@@ -359,7 +360,7 @@ class BatchTransform(EventWindow):
             self.compute_transform_value = self.get_value
 
         self.refresh_period = refresh_period
-        self.days = days
+        self.window_length = window_length
         self.trading_days_since_update = 0
         self.trading_days_total = 0
 
@@ -405,7 +406,7 @@ class BatchTransform(EventWindow):
             self.trading_days_total += 1
 
         if (
-            self.trading_days_total >= self.days and
+            self.trading_days_total >= self.window_length and
             self.trading_days_since_update >= self.refresh_period
         ):
 

zipline/transforms/vwap.py

@@ -26,20 +26,20 @@ class MovingVWAP(object):
     """
     __metaclass__ = TransformMeta
 
-    def __init__(self, market_aware=True, delta=None, days=None):
+    def __init__(self, market_aware=True, delta=None, window_length=None):
 
         self.market_aware = market_aware
         self.delta = delta
-        self.days = days
+        self.window_length = window_length
 
         # Market-aware mode only works with full-day windows.
         if self.market_aware:
-            assert self.days and not self.delta,\
+            assert self.window_length and not self.delta,\
                 "Market-aware mode only works with full-day windows."
 
         # Non-market-aware mode requires a timedelta.
         else:
-            assert self.delta and not self.days, \
+            assert self.delta and not self.window_length, \
                 "Non-market-aware mode requires a timedelta."
 
         # No way to pass arguments to the defaultdict factory, so we
@@ -50,7 +50,7 @@ class MovingVWAP(object):
         """Factory method for self.sid_windows."""
         return VWAPEventWindow(
             self.market_aware,
-            days=self.days,
+            window_length=self.window_length,
             delta=self.delta
         )
 
@@ -71,8 +71,8 @@ class VWAPEventWindow(EventWindow):
     Iteratively maintains a vwap for a single sid over a given
     timedelta.
     """
-    def __init__(self, market_aware, days=None, delta=None):
-        EventWindow.__init__(self, market_aware, days, delta)
+    def __init__(self, market_aware, window_length=None, delta=None):
+        EventWindow.__init__(self, market_aware, window_length, delta)
         self.flux = 0.0
         self.totalvolume = 0.0