Fix inconsistency in Partial String Index with 'second' resolution

ischurov · ischurov · commit cc86bddf47f9 · 2016-12-11T10:11:21.000+03:00
See pandas-dev#14826. Now the following logic applies: - If timestamp resolution is strictly less precise than index resolution, timetamp is a slice as it can (in theory) correspond to more than one elements in the index. For `Series`, `[]` should return `Series`, for `DataFrame` — `DataFrame`. - If timestamp resolution is equal to index resolution, then timestamp is considered as an attempt to get a kind of "exact match". For `Series`, `[]` should return scalar, for `DataFrame` — try to find column with this key (if any), and most probably raise `KeyError`. - If timestamp resolution is strictly more precise than index resolution and does not resolve to exact match, `KeyError` have to be raised in both cases. Testsuite is updated as well.
diff --git a/pandas/tseries/index.py b/pandas/tseries/index.py
@@ -1294,12 +1294,12 @@ def _parsed_string_to_bounds(self, reso, parsed):
     def _partial_date_slice(self, reso, parsed, use_lhs=True, use_rhs=True):
         is_monotonic = self.is_monotonic
         if (is_monotonic
-            and ((reso in ['day', 'hour', 'minute']
-                  and self._resolution >= Resolution.get_reso(reso))
-                 or (reso == 'second'
-                     and self._resolution > Resolution.RESO_SEC))):
+            and reso in ['day', 'hour', 'minute', 'second']
+            and self._resolution >= Resolution.get_reso(reso)):
             # These resolution/monotonicity validations came from GH3931,
             # GH3452 and GH2369.
+
+            # See also GH14826
             raise KeyError
 
         if reso == 'microsecond':
diff --git a/pandas/tseries/tests/test_partial_string_indexes.py b/pandas/tseries/tests/test_partial_string_indexes.py
@@ -0,0 +1,168 @@
+import nose
+import numpy as np
+
+import pandas.util.testing as tm
+from pandas import (
+    Index, Series, DataFrame, isnull, date_range, Timestamp, Period,
+    DatetimeIndex, Int64Index, to_datetime, bdate_range, Float64Index,
+    NaT, timedelta_range, Timedelta, _np_version_under1p8, concat)
+
+from pandas.util.testing import (
+    assert_frame_equal, assert_series_equal, assert_almost_equal,
+    _skip_if_has_locale, slow)
+
+class TestTimeSeriesPartialSlices(tm.TestCase):
+    _multiprocess_can_split_ = True
+    def assert_exact(self, df, ts, value):
+        element = df['a'][ts]
+
+        # Series should return scalar
+        self.assertIsInstance(element, np.int64)
+        self.assertEqual(element, value)
+
+        # Frame should raise (exact match)
+        self.assertRaises(KeyError, df.__getitem__, ts)
+
+        #TODO: test falling to column selection
+
+    def assert_slice(self, df, ts, slice):
+        # Series should return slice
+        expected = df['a'][slice]
+        assert_series_equal(df['a'][ts], expected)
+
+        # Frame should return slice as well
+        expected = df[slice]
+        assert_frame_equal(df[ts], expected)
+
+    def assert_key_error(self, df, ts):
+        self.assertRaises(KeyError, df['a'].__getitem__, ts)
+        self.assertRaises(KeyError, df.__getitem__, ts)
+
+    def test_partial_slices_day(self):
+        df = DataFrame({'a': [1, 2, 3]}, DatetimeIndex(['2011-12-31',
+                                                        '2012-01-01',
+                                                        '2012-01-02']),
+                       dtype=np.int64)
+
+        self.assertEqual(df.index.resolution, 'day')
+
+        # Timestamp with resolution 'day'
+        self.assert_exact(df, '2011-12-31', 1)
+        self.assert_exact(df, '2012-01-01', 2)
+        self.assert_exact(df, '2012-01-02', 3)
+
+        # Timestamp with resolution less precise than 'day'
+        for ts in ['2011', '2011-12']:
+            self.assert_slice(df, ts, slice(None, 1))
+
+        # The same as previous but several elements in the slice
+        for ts in ['2012', '2012-01']:
+            self.assert_slice(df, ts, slice(1, None))
+
+        # Timestamp with resolution more precise than 'day'
+        # Compatible with existing key
+        for ts in ['2012-01-01 00', '2012-01-01 00:00',
+                   '2012-01-01 00:00:00']:
+            self.assert_exact(df, ts, 2)
+
+        # Timestamp with resolution more precise than 'day'
+        # Not compatible with existing key
+        for ts in ['2012-01-01 01', '2012-01-01 00:01',
+                   '2012-01-01 00:00:01']:
+            self.assert_key_error(df, ts)
+
+
+    def test_partial_slice_hour(self):
+        df = DataFrame({'a': [1, 2, 3]}, DatetimeIndex(['2011-12-31 23',
+                                                        '2012-01-01 00',
+                                                        '2012-01-01 01']),
+                       dtype=np.int64)
+
+        self.assertEqual(df.index.resolution, 'hour')
+
+        # Timestamp with resolution 'hour'
+        self.assert_exact(df, '2011-12-31 23', 1)
+        self.assert_exact(df, '2012-01-01 00', 2)
+        self.assert_exact(df, '2012-01-01 01', 3)
+
+        # Timestamp with resolution less precise than 'hour'
+        for ts in ['2011', '2011-12', '2011-12-31']:
+            self.assert_slice(df, ts, slice(None, 1))
+
+        # The same as previous but several elements in the slice
+        for ts in ['2012', '2012-01', '2012-01-01']:
+            self.assert_slice(df, ts, slice(1, None))
+
+        # Timestamp with resolution more precise than 'hour'
+        # Compatible with existing key
+        for ts in ['2012-01-01 00:00',
+                   '2012-01-01 00:00:00']:
+            self.assert_exact(df, ts, 2)
+
+        # Timestamp with resolution more precise than 'hour'
+        # Not compatible with existing key
+        for ts in ['2012-01-01 00:01',
+                   '2012-01-01 00:00:01']:
+            self.assert_key_error(df, ts)
+
+    def test_partial_slice_minute(self):
+        df = DataFrame({'a': [1, 2, 3]},
+                       DatetimeIndex(['2011-12-31 23:59',
+                                      '2012-01-01 00:00',
+                                      '2012-01-01 00:01']),
+                       dtype=np.int64)
+
+        self.assertEqual(df.index.resolution, 'minute')
+
+        # Timestamp with resolution 'minute'
+        self.assert_exact(df, '2011-12-31 23:59', 1)
+        self.assert_exact(df, '2012-01-01 00:00', 2)
+        self.assert_exact(df, '2012-01-01 00:01', 3)
+
+        # Timestamp with resolution less precise than 'minute'
+        for ts in ['2011', '2011-12', '2011-12-31',
+                   '2011-12-31 23']:
+            self.assert_slice(df, ts, slice(None, 1))
+
+        # The same as previous but several elements in the slice
+        for ts in ['2012', '2012-01', '2012-01-01',
+                   '2012-01-01 00']:
+            self.assert_slice(df, ts, slice(1, None))
+
+        # Timestamp with resolution more precise than 'minute'
+        # Compatible with existing key
+        for ts in ['2012-01-01 00:00:00']:
+            self.assert_exact(df, ts, 2)
+
+        # Timestamp with resolution more precise than 'minute'
+        # Not compatible with existing key
+        for ts in ['2012-01-01 00:00:01']:
+            self.assert_key_error(df, ts)
+
+    def test_partial_slice_second(self):
+        # See GH14826
+        df = DataFrame({'a': [1, 2, 3]},
+                       DatetimeIndex(['2011-12-31 23:59:59',
+                                      '2012-01-01 00:00:00',
+                                      '2012-01-01 00:00:01']),
+                       dtype=np.int64)
+
+        self.assertEqual(df.index.resolution, 'second')
+
+        # Timestamp with resolution 'second'
+        self.assert_exact(df, '2011-12-31 23:59:59', 1)
+        self.assert_exact(df, '2012-01-01 00:00:00', 2)
+        self.assert_exact(df, '2012-01-01 00:00:01', 3)
+
+        # Timestamp with resolution less precise than 'second'
+        for ts in ['2011', '2011-12', '2011-12-31',
+                   '2011-12-31 23', '2011-12-31 23:59']:
+            self.assert_slice(df, ts, slice(None, 1))
+
+        # The same as previous but several elements in the slice
+        for ts in ['2012', '2012-01', '2012-01-01',
+                   '2012-01-01 00', '2012-01-01 00:00']:
+            self.assert_slice(df, ts, slice(1, None))
+
+        # Not possible to create a string that represents timestamp
+        # that is more exact then 'second'
diff --git a/pandas/tseries/tests/test_timeseries.py b/pandas/tseries/tests/test_timeseries.py
@@ -266,18 +266,18 @@ def test_indexing(self):
         expected = ts['2013']
         assert_series_equal(expected, ts)
 
-        # GH 3925, indexing with a seconds resolution string / datetime object
+        # GH14826, indexing with a seconds resolution string / datetime object
         df = DataFrame(randn(5, 5),
                        columns=['open', 'high', 'low', 'close', 'volume'],
                        index=date_range('2012-01-02 18:01:00',
                                         periods=5, tz='US/Central', freq='s'))
         expected = df.loc[[df.index[2]]]
-        result = df['2012-01-02 18:01:02']
-        assert_frame_equal(result, expected)
 
         # this is a single date, so will raise
+        self.assertRaises(KeyError, df.__getitem__, '2012-01-02 18:01:02', )
         self.assertRaises(KeyError, df.__getitem__, df.index[2], )
 
+
     def test_recreate_from_data(self):
         freqs = ['M', 'Q', 'A', 'D', 'B', 'BH', 'T', 'S', 'L', 'U', 'H', 'N',
                  'C']
