Merge remote-tracking branch 'upstream/master'

Author: fvia

doc/source/whatsnew/v0.15.2.txt

@@ -97,6 +97,7 @@ Bug Fixes
 - ``sql_schema`` now generates dialect appropriate ``CREATE TABLE`` statements (:issue:`8697`)
 - ``slice`` string method now takes step into account (:issue:`8754`)
 - Bug in ``BlockManager`` where setting values with different type would break block integrity (:issue:`8850`)
+- Bug in ``DatetimeIndex`` when using ``time`` object as key (:issue:`8667`)
 - Fix negative step support for label-based slices (:issue:`8753`)
 
   Old behavior:
@@ -142,7 +143,7 @@ Bug Fixes
 
 
 
-
+- BUG: Option context applies on __enter__ (:issue:`8514`)
 
 
 

pandas/core/common.py

@@ -404,9 +404,13 @@ def array_equivalent(left, right, strict_nan=False):
 
     Examples
     --------
-    >>> array_equivalent(np.array([1, 2, nan]), np.array([1, 2, nan]))
+    >>> array_equivalent(
+    ...     np.array([1, 2, np.nan]),
+    ...     np.array([1, 2, np.nan]))
     True
-    >>> array_equivalent(np.array([1, nan, 2]), np.array([1, 2, nan]))
+    >>> array_equivalent(
+    ...     np.array([1, np.nan, 2]),
+    ...     np.array([1, 2, np.nan]))
     False
     """
 
@@ -2171,8 +2175,8 @@ def iterpairs(seq):
 
     Examples
     --------
-    >>> iterpairs([1, 2, 3, 4])
-    [(1, 2), (2, 3), (3, 4)
+    >>> list(iterpairs([1, 2, 3, 4]))
+    [(1, 2), (2, 3), (3, 4)]
     """
     # input may not be sliceable
     seq_it = iter(seq)

pandas/core/config.py

@@ -385,19 +385,18 @@ def __init__(self, *args):
                 'option_context(pat, val, [(pat, val), ...)).'
             )
 
-        ops = list(zip(args[::2], args[1::2]))
+        self.ops = list(zip(args[::2], args[1::2]))
+
+    def __enter__(self):
         undo = []
-        for pat, val in ops:
+        for pat, val in self.ops:
             undo.append((pat, _get_option(pat, silent=True)))
 
         self.undo = undo
 
-        for pat, val in ops:
+        for pat, val in self.ops:
             _set_option(pat, val, silent=True)
 
-    def __enter__(self):
-        pass
-
     def __exit__(self, *args):
         if self.undo:
             for pat, val in self.undo:

pandas/index.pyx

@@ -545,8 +545,14 @@ cdef class DatetimeEngine(Int64Engine):
                 val = _to_i8(val)
                 return self._get_loc_duplicates(val)
             values = self._get_index_values()
-            conv = _to_i8(val)
-            loc = values.searchsorted(conv, side='left')
+
+            try:
+                conv = _to_i8(val)
+                loc = values.searchsorted(conv, side='left')
+            except TypeError:
+                self._date_check_type(val)
+                raise KeyError(val)
+
             if loc == len(values) or util.get_value_at(values, loc) != conv:
                 raise KeyError(val)
             return loc

pandas/tests/test_config.py

@@ -425,3 +425,24 @@ def f3(key):
         options.c = 1
         self.assertEqual(len(holder), 1)
 
+    def test_option_context_scope(self):
+        # Ensure that creating a context does not affect the existing
+        # environment as it is supposed to be used with the `with` statement.
+        # See https://github.com/pydata/pandas/issues/8514
+
+        original_value = 60
+        context_value = 10
+        option_name = 'a'
+
+        self.cf.register_option(option_name, original_value)
+
+        # Ensure creating contexts didn't affect the current context.
+        ctx = self.cf.option_context(option_name, context_value)
+        self.assertEqual(self.cf.get_option(option_name), original_value)
+
+        # Ensure the correct value is available inside the context.
+        with ctx:
+            self.assertEqual(self.cf.get_option(option_name), context_value)
+
+        # Ensure the current context is reset
+        self.assertEqual(self.cf.get_option(option_name), original_value)

pandas/tests/test_index.py

@@ -1887,6 +1887,27 @@ def test_reindex_preserves_tz_if_target_is_empty_list_or_array(self):
         self.assertEqual(str(index.reindex([])[0].tz), 'US/Eastern')
         self.assertEqual(str(index.reindex(np.array([]))[0].tz), 'US/Eastern')
 
+    def test_time_loc(self):  # GH8667
+        from datetime import time
+        from pandas.index import _SIZE_CUTOFF
+
+        ns = _SIZE_CUTOFF + np.array([-100, 100])
+        key = time(15, 11, 30)
+        start = key.hour * 3600 + key.minute * 60 + key.second
+        step = 24 * 3600
+
+        for n in ns:
+            idx = pd.date_range('2014-11-26', periods=n, freq='S')
+            ts = pd.Series(np.random.randn(n), index=idx)
+            i = np.arange(start, n, step)
+
+            tm.assert_array_equal(ts.index.get_loc(key), i)
+            tm.assert_series_equal(ts[key], ts.iloc[i])
+
+            left, right = ts.copy(), ts.copy()
+            left[key] *= -10
+            right.iloc[i] *= -10
+            tm.assert_series_equal(left, right)
 
 class TestPeriodIndex(Base, tm.TestCase):
     _holder = PeriodIndex

pandas/tseries/index.py

@@ -1210,6 +1210,10 @@ def get_value(self, series, key):
 
             return self.get_value_maybe_box(series, key)
 
+        if isinstance(key, time):
+            locs = self.indexer_at_time(key)
+            return series.take(locs)
+
         try:
             return _maybe_box(self, Index.get_value(self, series, key), series, key)
         except KeyError:
@@ -1219,10 +1223,6 @@ def get_value(self, series, key):
             except (TypeError, ValueError, KeyError):
                 pass
 
-            if isinstance(key, time):
-                locs = self.indexer_at_time(key)
-                return series.take(locs)
-
             try:
                 return self.get_value_maybe_box(series, key)
             except (TypeError, ValueError, KeyError):
@@ -1250,6 +1250,9 @@ def get_loc(self, key):
             stamp = Timestamp(key, tz=self.tz)
             return self._engine.get_loc(stamp)
 
+        if isinstance(key, time):
+            return self.indexer_at_time(key)
+
         try:
             return Index.get_loc(self, key)
         except (KeyError, ValueError):
@@ -1258,9 +1261,6 @@ def get_loc(self, key):
             except (TypeError, KeyError, ValueError):
                 pass
 
-            if isinstance(key, time):
-                return self.indexer_at_time(key)
-
             try:
                 stamp = Timestamp(key, tz=self.tz)
                 return self._engine.get_loc(stamp)