BUG: loc misbehaves when Period is at start of 3-level MultiIndex

(pandas-dev#20684)

If `MultiIndex` is in PeriodIndex, `.loc` would raise exception with a miss match key

`PeriodEngine.get_loc` only accept Period.ordinal

Author: proost

doc/source/whatsnew/v1.0.0.rst

@@ -173,8 +173,8 @@ Missing
 
 MultiIndex
 ^^^^^^^^^^
-
 -
+- Using `.loc` with a `PeriodIndex` as a level in a `MultiIndex`, `.loc` could not raise exception when key is not matched (:issue:`20684`)
 -
 
 I/O

pandas/_libs/index.pyx

@@ -24,6 +24,7 @@ from pandas._libs.hashtable cimport HashTable
 from pandas._libs import algos, hashtable as _hash
 from pandas._libs.tslibs import Timestamp, Timedelta, period as periodlib
 from pandas._libs.missing import checknull
+from pandas._libs.tslibs.util cimport is_period_object
 
 cdef int64_t NPY_NAT = util.get_nat()
 
@@ -479,7 +480,7 @@ cdef class TimedeltaEngine(DatetimeEngine):
 cdef class PeriodEngine(Int64Engine):
 
     cdef _get_index_values(self):
-        return super(PeriodEngine, self).vgetter()
+        return super(PeriodEngine, self).vgetter().view('i8')
 
     cpdef _call_map_locations(self, values):
         super(PeriodEngine, self)._call_map_locations(values.view('i8'))

pandas/_libs/tslibs/parsing.pyx

@@ -251,10 +251,8 @@ def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
     -------
     datetime, datetime/dateutil.parser._result, str
     """
-    if not isinstance(arg, (str, unicode)):
-        # Note: cython recognizes `unicode` in both py2/py3, optimizes
-        # this check into a C call.
-        return arg
+    if not isinstance(arg, str):
+        raise TypeError
 
     if getattr(freq, "_typ", None) == "dateoffset":
         freq = freq.rule_code

pandas/core/indexes/period.py

@@ -702,36 +702,37 @@ def get_loc(self, key, method=None, tolerance=None):
         -------
         loc : int
         """
+        if is_integer(key):
+            ordinal = key
+        else:
+            key = self._cast_period_object(key)
+            ordinal = iNaT if key is NaT else key.ordinal
+
+        if tolerance is not None:
+            tolerance = self._convert_tolerance(tolerance, np.asarray(key))
+
         try:
-            return self._engine.get_loc(key)
+            return self._int64index.get_loc(ordinal, method, tolerance)
         except KeyError:
-            if is_integer(key):
-                raise
+            raise KeyError(key)
 
+    def _cast_period_object(self, key):
+        if isinstance(key, str):
             try:
                 asdt, parsed, reso = parse_time_string(key, self.freq)
                 key = asdt
-            except TypeError:
-                pass
             except DateParseError:
                 # A string with invalid format
                 raise KeyError("Cannot interpret '{}' as period".format(key))
 
-            try:
-                key = Period(key, freq=self.freq)
-            except ValueError:
-                # we cannot construct the Period
-                # as we have an invalid type
-                raise KeyError(key)
-
-            try:
-                ordinal = iNaT if key is NaT else key.ordinal
-                if tolerance is not None:
-                    tolerance = self._convert_tolerance(tolerance, np.asarray(key))
-                return self._int64index.get_loc(ordinal, method, tolerance)
-
-            except KeyError:
-                raise KeyError(key)
+        try:
+            return Period(key, freq=self.freq)
+        except TypeError:
+            raise TypeError("'{key}' is an invalid key".format(key=key))
+        except ValueError:
+            # we cannot construct the Period
+            # as we have an invalid type
+            raise KeyError(key)
 
     def _maybe_cast_slice_bound(self, label, side, kind):
         """

pandas/tests/indexes/period/test_period.py

@@ -617,6 +617,72 @@ def test_insert(self):
             result = period_range("2017Q1", periods=4, freq="Q").insert(1, na)
             tm.assert_index_equal(result, expected)
 
+    def test_contains_raise_error_if_period_index_is_in_multi_index(self):
+        # issue 20684
+        df = DataFrame(
+            {
+                "A": [Period("2019"), "x1"],
+                "B": ["y1", Period("2018")],
+                "C": ["z1", "z2"],
+                "V1": [1, 2],
+                "V2": [10, 20],
+            }
+        ).set_index(["A", "B", "C"])
+        msg = r"Period\('2019', 'A-DEC'\), 'foo', 'bar'"
+        with pytest.raises(KeyError, match=msg):
+            df.loc[(Period("2019"), "foo", "bar")]
+
+        msg = r"'foo', Period\('2018', 'A-DEC'\), 'bar'"
+        with pytest.raises(KeyError, match=msg):
+            df.loc[("foo", Period("2018"), "bar")]
+
+        pbc = DataFrame(
+            {"p": [Period("2017")], "b": ["b1"], "c": ["c1"], "v": [1]}
+        ).set_index(["p", "b", "c"])
+        msg = r"Period\('2017', 'A-DEC'\), 'wibble', 'c1'"
+        with pytest.raises(KeyError, match=msg):
+            pbc.loc[(Period("2017"), "wibble", "c1")]
+
+        msg = r"Period\('2017', 'A-DEC'\), 'b1', 'wobble'"
+        with pytest.raises(KeyError, match=msg):
+            pbc.loc[(Period("2017"), "b1", "wobble"), "v"]
+
+        ybc = DataFrame({"y": ["2017"], "b": ["b1"], "c": ["c1"], "v": [1]}).set_index(
+            ["y", "b", "c"]
+        )
+        assert ybc.loc[("2017", "b1", "c1"), "v"] == 1
+
+        msg = r"'2017', 'b1', 'wobble'"
+        with pytest.raises(KeyError, match=msg):
+            ybc.loc[("2017", "b1", "wobble"), "v"]
+
+        pb = DataFrame({"p": [Period("2017")], "b": ["b1"], "v": [1]}).set_index(
+            ["p", "b"]
+        )
+        assert pb.loc[(Period("2017"), "b1"), "v"] == 1
+
+        msg = r"Period\('2017', 'A-DEC'\), 'wibble'"
+        with pytest.raises(KeyError, match=msg):
+            pb.loc[(Period("2017"), "wibble"), "v"]
+
+        bcp = pd.DataFrame(
+            {"p": [Period("2017")], "b": ["b1"], "c": ["c1"], "v": [1]}
+        ).set_index(["b", "c", "p"])
+        assert bcp.loc[("b1", "c1", Period("2017")), "v"] == 1
+
+        msg = r"'b1', 'wibble', Period\('2017', 'A-DEC'\)"
+        with pytest.raises(KeyError, match=msg):
+            bcp.loc[("b1", "wibble", Period("2017")), "v"]
+
+        bpc = pd.DataFrame(
+            {"p": [Period("2017")], "b": ["b1"], "c": ["c1"], "v": [1]}
+        ).set_index(["b", "p", "c"])
+        assert bpc.loc[("b1", Period("2017"), "c1"), "v"] == 1
+
+        msg = r"'b1', Period\('2017', 'A-DEC'\), 'wibble'"
+        with pytest.raises(KeyError, match=msg):
+            bpc.loc[("b1", Period("2017"), "wibble"), "v"]
+
 
 def test_maybe_convert_timedelta():
     pi = PeriodIndex(["2000", "2001"], freq="D")

pandas/tests/tslibs/test_parsing.py

@@ -209,3 +209,13 @@ def test_try_parse_dates():
 
     expected = np.array([parse(d, dayfirst=True) for d in arr])
     tm.assert_numpy_array_equal(result, expected)
+
+
+def test_parse_time_string_check_instance_type_raise_exception():
+    # issue 20684
+    with pytest.raises(TypeError):
+        parse_time_string((1, 2, 3))
+
+    result = parse_time_string("2019")
+    expected = (datetime(2019, 1, 1), datetime(2019, 1, 1), "year")
+    assert result == expected