Almost there

Not allowing closed parameter for fixed windows
Passing tests again
Updating docs

Author: carlosdanielcsantos

doc/source/computation.rst

@@ -466,19 +466,35 @@ Rolling window endpoint inclusion
 
 .. versionadded:: 0.20.0
 
-New in version 0.19.0 are the ability to pass an offset (or convertible) to a ``.rolling()`` method and have it produce
-variable sized windows based on the passed time window. For each time point, this includes all preceding values occurring
-within the indicated time delta.
+The inclusion of the interval endpoints in rolling window calculations can be specified with the ``closed``
+parameter:
 
-This can be particularly useful for a non-regular time frequency index.
+  - ``right`` : close right endpoint (default for time-based windows)
+  - ``left`` : close left endpoint
+  - ``both`` : close both endpoints (default for fixed windows)
+  - ``neither`` : open endpoints
+
+For example, having the right endpoint open is useful in many problems that require that there is no contamination
+from present information back to past information. This allows the rolling window to compute statistics
+"up to that point in time", but not including that point in time.
 
 .. ipython:: python
 
-   dft = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},
-                      index=pd.date_range('20130101 09:00:00', periods=5, freq='s'))
-   dft
+   df = pd.DataFrame({'x': [1]*5},
+                     index = [pd.Timestamp('20130101 09:00:01'),
+                              pd.Timestamp('20130101 09:00:02'),
+                              pd.Timestamp('20130101 09:00:03'),
+                              pd.Timestamp('20130101 09:00:04'),
+                              pd.Timestamp('20130101 09:00:06')])
 
-This is a regular frequency index. Using an integer window parameter works to roll along the window frequency.
+   df["right"] = df.rolling('2s', closed='right').x.sum() # default
+   df["both"] = df.rolling('2s', closed='both').x.sum()
+   df["left"] = df.rolling('2s', closed='left').x.sum()
+   df["open"] = df.rolling('2s', closed='neither').x.sum()
+
+   df
+
+Currently, this feature is only implemented for time-based windows.
 
 .. _stats.moments.ts-versus-resampling:
 

pandas/core/generic.py

@@ -5962,7 +5962,7 @@ def _add_series_or_dataframe_operations(cls):
 
         @Appender(rwindow.rolling.__doc__)
         def rolling(self, window, min_periods=None, freq=None, center=False,
-                    win_type=None, on=None, axis=0, closed='right'):
+                    win_type=None, on=None, axis=0, closed=None):
             axis = self._get_axis_number(axis)
             return rwindow.rolling(self, window=window,
                                    min_periods=min_periods, freq=freq,

pandas/core/window.py

@@ -103,7 +103,8 @@ def validate(self):
         if self.min_periods is not None and not \
            is_integer(self.min_periods):
             raise ValueError("min_periods must be an integer")
-        if self.closed not in ['right', 'both', 'left', 'neither']:
+        if self.closed is not None and self.closed not in \
+           ['right', 'both', 'left', 'neither']:
             raise ValueError("closed must be 'right', 'left', 'both' or "
                              "'neither'")
 
@@ -1056,6 +1057,9 @@ def validate(self):
             raise ValueError("window must be an integer")
         elif self.window < 0:
             raise ValueError("window must be non-negative")
+        elif self.closed is not None:
+            raise ValueError("closed only implemented for datetimelike "
+                                         "and offset based windows")
 
     def _validate_monotonic(self):
         """ validate on is monotonic """

pandas/core/window.pyx

@@ -248,7 +248,7 @@ cdef class VariableWindowIndexer(WindowIndexer):
 
     """
     def __init__(self, ndarray input, int64_t win, int64_t minp,
-                 ndarray index, bint left_closed, bint right_closed):
+                 bint left_closed, bint right_closed, ndarray index):
 
         self.is_variable = 1
         self.N = len(index)
@@ -330,9 +330,10 @@ def get_window_indexer(input, win, minp, index, closed,
     minp: integer, minimum periods
     index: 1d ndarray, optional
         index to the input array
-    closed: string, default 'right'
+    closed: string, default None
         {'right', 'left', 'both', 'neither'}
-        window endpoint closedness
+        window endpoint closedness. Defaults to 'right' in
+        VariableWindowIndexer and to 'both' in FixedWindowIndexer
     floor: optional
         unit for flooring the unit
     use_mock: boolean, default True
@@ -365,14 +366,14 @@ def get_window_indexer(input, win, minp, index, closed,
         left_closed = True
 
     if index is not None:
-        indexer = VariableWindowIndexer(input, win, minp, index, left_closed,
-                                        right_closed)
+        indexer = VariableWindowIndexer(input, win, minp, left_closed,
+                                        right_closed, index)
     elif use_mock:
-        indexer = MockFixedWindowIndexer(input, win, minp, index, floor,
-                                         left_closed, right_closed)
+        indexer = MockFixedWindowIndexer(input, win, minp, left_closed,
+                                         right_closed, index, floor)
     else:
-        indexer = FixedWindowIndexer(input, win, minp, index, floor, left_closed,
-                                     right_closed)
+        indexer = FixedWindowIndexer(input, win, minp, left_closed,
+                                     right_closed, index, floor)
     return indexer.get_data()
 
 # ----------------------------------------------------------------------

pandas/tests/test_window.py

@@ -3396,6 +3396,10 @@ def test_closed(self):
                               pd.Timestamp('20130101 09:00:04'),
                               pd.Timestamp('20130101 09:00:06')])
 
+        # closed only allowed for datetimelike
+        with self.assertRaises(ValueError):
+             self.regular.rolling(window=3, closed='both')
+
         # closed must be 'right', 'left', 'both', 'neither'
         with self.assertRaises(ValueError):
             self.regular.rolling(window='2s', closed="blabla")