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,
@@ -561,6 +563,106 @@ 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.
+        copy : bool, default False
+            Copy the data.
+        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],
+    ) -> IntervalArrayT:
+        # These need to be imported here to avoid circular dependencies.
+        from pandas.core.tools.datetimes import to_datetime
+        from pandas.core.tools.timedeltas import to_timedelta
+
+        intervals: list[Interval] = []
+        for string in data:
+
+            # Try to match "(left, right]" where 'left' and 'right' are breaks.
+            breaks_match = re.match(r"\(.*,.*]", string)
+            # Raise ValueError if no match was found.
+            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:
+                    interval = Interval(*map(conversion, breaks))
+                    break
+                except ValueError:
+                    continue
+            else:
+                raise ValueError(
+                    "Could not parse string as Interval of float, Timedelta "
+                    f"or Timestamp: {string}"
+                )
+            intervals.append(interval)
+
+        return cls(intervals)
+
     def _validate(self):
         """
         Verify that the IntervalArray is valid.

pandas/core/indexes/interval.py

@@ -11,6 +11,7 @@
     TYPE_CHECKING,
     Any,
     Hashable,
+    Sequence,
     cast,
 )
 
@@ -378,6 +379,32 @@ 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],
+        name: Hashable = None,
+    ) -> IntervalIndex:
+        with rewrite_exception("IntervalArray", cls.__name__):
+            arr = IntervalArray.from_strings(data=data)
+
+        return cls._simple_new(arr, name=name)
+
     # --------------------------------------------------------------------
 
     @cache_readonly

pandas/tests/indexes/interval/test_interval.py

@@ -906,6 +906,42 @@ def test_pickle_round_trip_closed(self, closed):
         tm.assert_index_equal(result, idx)
 
 
+def test_from_strings():
+    """Test the IntervalIndex.from_strings class method."""
+    # Create (expected, string_repr) tuples for test-cases.
+    test_cases = [
+        (
+            IntervalIndex.from_breaks([0.0, 0.5, 1.0]),
+            ["(0.0, 0.5]", "(0.5, 1.0]"],
+        ),
+        (IntervalIndex.from_breaks([0, 5, 10]), ["(0, 5]", "(5, 10]"]),
+        (
+            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]"],
+        ),
+    ]
+    # Validate each test case.
+    for expected, string in test_cases:
+        parsed_index = IntervalIndex.from_strings(string)
+        assert np.array_equal(parsed_index, expected)
+
+
+def test_from_strings_errors():
+    """Validate the error messages from the IntervalIndex.from_strings method."""
+    # Create invalid interval indices (to make sure it fails correctly)
+    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"),
+    ]
+    # Validate that all cases raise ValueErrors with the correct message
+    for string, error in 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])