BUG: Parsing week-freq Periods

Author: jbrockmendel

doc/source/whatsnew/v2.0.0.rst

@@ -1032,6 +1032,8 @@ Period
 - Bug in :meth:`Period.strftime` and :meth:`PeriodIndex.strftime`, raising ``UnicodeDecodeError`` when a locale-specific directive was passed (:issue:`46319`)
 - Bug in adding a :class:`Period` object to an array of :class:`DateOffset` objects incorrectly raising ``TypeError`` (:issue:`50162`)
 - Bug in :class:`Period` where passing a string with finer resolution than nanosecond would result in a ``KeyError`` instead of dropping the extra precision (:issue:`50417`)
+- Bug in parsing strings representing Week-periods e.g. "2017-01-23/2017-01-29" as minute-frequency instead of week-frequency (:issue:`??`)
+-
 
 Plotting
 ^^^^^^^^

pandas/_libs/tslibs/period.pyx

@@ -1,3 +1,5 @@
+import re
+
 cimport numpy as cnp
 from cpython.object cimport (
     Py_EQ,
@@ -2591,20 +2593,30 @@ class Period(_Period):
             value = value.upper()
 
             freqstr = freq.rule_code if freq is not None else None
-            dt, reso = parse_datetime_string_with_reso(value, freqstr)
-            if reso == "nanosecond":
-                nanosecond = dt.nanosecond
-            if dt is NaT:
-                ordinal = NPY_NAT
 
-            if freq is None and ordinal != NPY_NAT:
-                # Skip NaT, since it doesn't have a resolution
-                try:
-                    freq = attrname_to_abbrevs[reso]
-                except KeyError:
-                    raise ValueError(f"Invalid frequency or could not "
-                                     f"infer: {reso}")
-                freq = to_offset(freq)
+            try:
+                dt, reso = parse_datetime_string_with_reso(value, freqstr)
+            except ValueError:
+                match = re.search(r"^\d{4}-\d{2}-\d{2}/\d{4}-\d{2}-\d{2}", value)
+                if not match:
+                    raise
+                # Case that cannot be parsed (correctly) by our datetime
+                #  parsing logic
+                dt, freq = parse_weekly_str(value, freq)
+            else:
+                if reso == "nanosecond":
+                    nanosecond = dt.nanosecond
+                if dt is NaT:
+                    ordinal = NPY_NAT
+
+                if freq is None and ordinal != NPY_NAT:
+                    # Skip NaT, since it doesn't have a resolution
+                    try:
+                        freq = attrname_to_abbrevs[reso]
+                    except KeyError:
+                        raise ValueError(f"Invalid frequency or could not "
+                                         f"infer: {reso}")
+                    freq = to_offset(freq)
 
         elif PyDateTime_Check(value):
             dt = value
@@ -2664,3 +2676,31 @@ def validate_end_alias(how: str) -> str:  # Literal["E", "S"]
     if how not in {"S", "E"}:
         raise ValueError("How must be one of S or E")
     return how
+
+
+cdef parse_weekly_str(value, BaseOffset freq):
+    """
+    Parse e.g. "2017-01-23/2017-01-29", which cannot be parsed by the general
+    datetime-parsing logic.  This ensures that we can round-trip with
+    Period.__str__ with weekly freq.
+    """
+    match = re.search(r"^\d{4}-\d{2}-\d{2}/\d{4}-\d{2}-\d{2}", value)
+    if not match:
+        raise ValueError("Could not parse as weekly-freq Period")
+
+    start, end = value.split("/")
+    start = Timestamp(start)
+    end = Timestamp(end)
+
+    if (end - start).days != 6:
+        # We are interested in cases where this is str(period)
+        #  of a Week-freq period
+        raise ValueError("Could not parse as weekly-freq Period")
+
+    if freq is None:
+        day_name = end.day_name()[:3].upper()
+        freqstr = f"W-{day_name}"
+        freq = to_offset(freqstr)
+        # We _should_ have freq.is_on_offset(end)
+
+    return end, freq

pandas/tests/scalar/period/test_period.py

@@ -399,6 +399,18 @@ def test_period_cons_weekly(self, num, day):
         assert result == expected
         assert isinstance(result, Period)
 
+    def test_parse_week_str_roundstrip(self):
+        per = Period("2017-01-23/2017-01-29")
+        assert per.freq.freqstr == "W-SUN"
+
+        per = Period("2017-01-24/2017-01-30")
+        assert per.freq.freqstr == "W-MON"
+
+        msg = "Could not parse as weekly-freq Period"
+        with pytest.raises(ValueError, match=msg):
+            # not 6 days apart
+            Period("2016-01-23/2017-01-29")
+
     def test_period_from_ordinal(self):
         p = Period("2011-01", freq="M")
         res = Period._from_ordinal(p.ordinal, freq="M")