Parse IntervalArray and IntervalIndex from strings

pandas/core/arrays/interval.py

@@ -5,8 +5,10 @@
     le,
     lt,
 )
+import re
 import textwrap
 from typing import (
+    Callable,
     Sequence,
     TypeVar,
     cast,
@@ -562,6 +564,117 @@ def from_tuples(
 
         return cls.from_arrays(left, right, closed, copy=False, dtype=dtype)
 
+    _interval_shared_docs["from_strings"] = textwrap.dedent(
+        """
+        Construct from string representations of the left and right bounds.
+
+        Parameters
+        ----------
+        data : array-like (1-dimensional)
+            Strings representing the Interval's to parse.
+        closed : {'left', 'right', 'both', 'neither'}, default 'right'
+            Whether the intervals are closed on the left-side, right-side, both
+            or neither.
+        dtype : dtype, optional
+            If None, dtype will be inferred.
+
+        Returns
+        -------
+        %(klass)s
+
+        Raises
+        ------
+        ValueError
+            When a string cannot be parsed as an Interval
+            When the dtype of the string cannot be parsed as either float,
+            Timestamp or Timedelta
+
+        See Also
+        --------
+        interval_range : Function to create a fixed frequency IntervalIndex.
+        %(klass)s.from_breaks : Construct an %(klass)s from an array of
+            splits.
+        %(klass)s.from_tuples : Construct an %(klass)s from an
+            array-like of tuples.
+
+        %(examples)s\
+        """
+    )
+
+    @classmethod
+    @Appender(
+        _interval_shared_docs["from_strings"]
+        % {
+            "klass": "IntervalIndex",
+            "examples": textwrap.dedent(
+                """\
+        Examples
+        --------
+        >>> pd.IntervalIndex.from_strings(["(0, 1]", "(1, 2]"])
+        IntervalIndex([(0, 1], (1, 2]],
+                       dtype='interval[int64, right]')
+        """
+            ),
+        }
+    )
+    def from_strings(
+        cls: type[IntervalArrayT],
+        data: Sequence[str],
+        closed: str = "right",
+        dtype: Dtype | None = None,
+    ) -> IntervalArrayT:
+        # These need to be imported here to avoid circular dependencies.
+        from pandas import (
+            to_datetime,
+            to_timedelta,
+        )
+
+        pattern = re.compile(r"\(.*,.*]")
+
+        left, right = [], []
+        for string in data:
+
+            # Try to match "(left, right]" where 'left' and 'right' are breaks.
+            breaks_match = pattern.match(string)
+
+            if breaks_match is None:
+                raise ValueError(
+                    "Could not find opening '(' and closing ']' "
+                    f"brackets in string: '{string}'"
+                )
+            # Try to split 'left' and 'right' based on a comma and a space.
+            breaks = breaks_match.string[1:-1].split(", ", 1)
+
+            if len(breaks) != 2:
+                raise ValueError(
+                    f"Delimiter ', ' (comma + space) not found in string: {string}"
+                )
+
+            conversions: list[Callable] = [int, float, to_datetime, to_timedelta]
+            # Try to parse the breaks first as floats, then datetime, then timedelta.
+            for i, conversion in enumerate(conversions):
+                # Check if all breaks can be parsed as integers.
+                if i == 0 and not all(b.isdigit() for b in breaks):
+                    continue
+                try:
+                    newleft, newright = map(conversion, breaks)
+                    left.append(newleft)
+                    right.append(newright)
+                    break
+                except ValueError:
+                    continue
+            else:
+                raise ValueError(
+                    "Could not parse string as Interval of float, Timedelta "
+                    f"or Timestamp: {string}"
+                )
+
+        # If dtype was not an IntervalDtype, try to parse it as such.
+        if dtype is not None and not isinstance(dtype, IntervalDtype):
+            dtype = IntervalDtype(subtype=dtype, closed=closed)
+
+        return cls.from_arrays(left, right, closed=closed, copy=False, dtype=dtype)
+
     def _validate(self):
         """
         Verify that the IntervalArray is valid.

pandas/core/indexes/interval.py

@@ -9,6 +9,7 @@
 from typing import (
     Any,
     Hashable,
+    Sequence,
 )
 
 import numpy as np
@@ -314,6 +315,34 @@ def from_tuples(
             arr = IntervalArray.from_tuples(data, closed=closed, copy=copy, dtype=dtype)
         return cls._simple_new(arr, name=name)
 
+    @classmethod
+    @Appender(
+        _interval_shared_docs["from_strings"]
+        % {
+            "klass": "IntervalIndex",
+            "examples": textwrap.dedent(
+                """\
+        Examples
+        --------
+        >>> pd.IntervalIndex.from_strings(["(0, 1]", "(1, 2]"])
+        IntervalIndex([(0, 1], (1, 2]],
+                       dtype='interval[int64, right]')
+        """
+            ),
+        }
+    )
+    def from_strings(
+        cls,
+        data: Sequence[str],
+        closed: str = "right",
+        dtype: Dtype | None = None,
+        name: Hashable = None,
+    ) -> IntervalIndex:
+        with rewrite_exception("IntervalArray", cls.__name__):
+            arr = IntervalArray.from_strings(data=data, dtype=dtype, closed=closed)
+
+        return cls._simple_new(arr, name=name)
+
     # --------------------------------------------------------------------
 
     @cache_readonly

pandas/tests/indexes/interval/test_interval.py

@@ -926,6 +926,57 @@ def test_pickle_round_trip_closed(self, closed):
         tm.assert_index_equal(result, idx)
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        (
+            "float64",
+            IntervalIndex.from_breaks([0.0, 0.5, 1.0]),
+            ["(0.0, 0.5]", "(0.5, 1.0]"],
+        ),
+        ("int64", IntervalIndex.from_breaks([0, 5, 10]), ["(0, 5]", "(5, 10]"]),
+        (
+            "datetime64[ns]",
+            IntervalIndex.from_breaks(
+                [Timestamp(2015, 7, 1), Timestamp(2016, 8, 1), Timestamp(2018, 9, 1)]
+            ),
+            ["(2015-07-01, 2016-08-01]", "(2016-08-01, 2018-09-01]"],
+        ),
+    ],
+)
+def test_from_strings(test_case):
+    """Test the IntervalIndex.from_strings class method."""
+    # See https://github.com/pandas-dev/pandas/pull/41451
+    dtype, expected, string = test_case
+
+    # Attempt to parse the type dynamically
+    parsed_index = IntervalIndex.from_strings(string)
+    assert np.array_equal(parsed_index, expected)
+    assert parsed_index.left.dtype == dtype
+
+    # Parse it with a fixed dtype and assert that the result is correct.
+    parsed_index_static = IntervalIndex.from_strings(string, dtype=np.dtype(dtype))
+    assert np.array_equal(parsed_index, parsed_index_static)
+    assert parsed_index.dtype == parsed_index_static.dtype
+
+
+@pytest.mark.parametrize(
+    "wrong_indices",
+    [
+        ("('hello', 'there']", r"Could not parse string as Interval"),
+        ("(0.1,0.1)", r"Could not find opening '\(' and closing ']'"),
+        ("(0.0,0.5]", r"Delimiter ', ' .* not found"),
+    ],
+)
+def test_from_strings_errors(wrong_indices):
+    """Validate the error messages from the IntervalIndex.from_strings method."""
+    # See https://github.com/pandas-dev/pandas/pull/41451
+    string, error = wrong_indices
+
+    with pytest.raises(ValueError, match=error):
+        IntervalIndex.from_strings([string])
+
+
 def test_dir():
     # GH#27571 dir(interval_index) should not raise
     index = IntervalIndex.from_arrays([0, 1], [1, 2])