reverted most of changes as they are not the right solution to the issue

Author: fujiaxiang

doc/source/whatsnew/v1.0.0.rst

@@ -207,8 +207,6 @@ Other enhancements
 - The ``partition_cols`` argument in :meth:`DataFrame.to_parquet` now accepts a string (:issue:`27117`)
 - :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue: `30270`)
 - DataFrame constructor preserve `ExtensionArray` dtype with `ExtensionArray` (:issue:`11363`)
-- Added `positional` optional parameter in :meth:`DataFrame.reorder_levels` to specify the type of levels to use, labels or positions or both (:issue:`30289`)
-- Added `positional` optional parameter in :meth:`MultiIndex.reorder_levels` to specify the type of levels to use, labels or positions or both (:issue:`30289`)
 
 
 Build Changes
@@ -717,10 +715,8 @@ Datetimelike
 - Bug in :func:`pandas.to_datetime` failing for `deques` when using ``cache=True`` (the default) (:issue:`29403`)
 - Bug in :meth:`Series.item` with ``datetime64`` or ``timedelta64`` dtype, :meth:`DatetimeIndex.item`, and :meth:`TimedeltaIndex.item` returning an integer instead of a :class:`Timestamp` or :class:`Timedelta` (:issue:`30175`)
 - Bug in :class:`DatetimeIndex` addition when adding a non-optimized :class:`DateOffset` incorrectly dropping timezone information (:issue:`30336`)
-- Bug in :meth:`DataFrame.drop` where attempting to drop non-existent values from a DatetimeIndex would yield a confusing error message (:issue:`30399`)
 - Bug in :meth:`DataFrame.append` would remove the timezone-awareness of new data (:issue:`30238`)
 
-
 Timedelta
 ^^^^^^^^^
 - Bug in subtracting a :class:`TimedeltaIndex` or :class:`TimedeltaArray` from a ``np.datetime64`` object (:issue:`29558`)
@@ -850,7 +846,6 @@ Groupby/resample/rolling
 - Bug in :meth:`DataFrameGroupBy.agg` with timezone-aware datetime64 column incorrectly casting results to the original dtype (:issue:`29641`)
 - Bug in :meth:`DataFrame.groupby` when using axis=1 and having a single level columns index (:issue:`30208`)
 - Bug in :meth:`DataFrame.groupby` when using nunique on axis=1 (:issue:`30253`)
-- Bug in :meth:`GroupBy.quantile` with multiple q values when columns are integers (:issue:`30289`)
 
 Reshaping
 ^^^^^^^^^

pandas/core/frame.py

@@ -5040,7 +5040,7 @@ def swaplevel(self, i=-2, j=-1, axis=0):
             result.columns = result.columns.swaplevel(i, j)
         return result
 
-    def reorder_levels(self, order, axis=0, positional=None):
+    def reorder_levels(self, order, axis=0):
         """
         Rearrange index levels using input order. May not drop or duplicate levels.
 
@@ -5051,14 +5051,6 @@ def reorder_levels(self, order, axis=0, positional=None):
             (position) or by key (label).
         axis : int
             Where to reorder levels.
-        positional : bool, optional
-            How to interpret integer values in `order`.
-
-              * None (default): prefer treating the values as labels,
-                but fall back to positional if no label with that
-                value is value.
-              * True : only treat integer values as positions.
-              * False : only treat integer values as labels.
 
         Returns
         -------
@@ -5071,9 +5063,9 @@ def reorder_levels(self, order, axis=0, positional=None):
         result = self.copy()
 
         if axis == 0:
-            result.index = result.index.reorder_levels(order, positional=positional)
+            result.index = result.index.reorder_levels(order)
         else:
-            result.columns = result.columns.reorder_levels(order, positional=positional)
+            result.columns = result.columns.reorder_levels(order)
         return result
 
     # ----------------------------------------------------------------------

pandas/core/groupby/groupby.py

@@ -1938,9 +1938,7 @@ def post_processor(vals: np.ndarray, inference: Optional[Type]) -> np.ndarray:
             #  but this hits https://github.com/pandas-dev/pandas/issues/10710
             #  which doesn't reorder the list-like `q` on the inner level.
             order = np.roll(list(range(result.index.nlevels)), -1)
-            result = result.reorder_levels(
-                order, positional=True
-            )  # GH30289: reorder based on position, not labels
+            result = result.reorder_levels(order)
             result = result.reindex(q, level=-1)
 
             # fix order.

pandas/core/indexes/base.py

@@ -4551,7 +4551,7 @@ def get_indexer_non_unique(self, target):
 
         if is_categorical(target):
             tgt_values = np.asarray(target)
-        elif self.is_all_dates and target.is_all_dates:  # GH 30399
+        elif self.is_all_dates:
             tgt_values = target.asi8
         else:
             tgt_values = target._ndarray_values

pandas/core/indexes/multi.py

@@ -1282,53 +1282,31 @@ def _constructor(self):
     def inferred_type(self) -> str:
         return "mixed"
 
-    def _get_level_number_by_label(self, label) -> int:
-        try:
-            level = self.names.index(label)
-        except ValueError:
-            raise KeyError(f"Level {label} not found")
-        return level
-
-    def _get_level_number_by_position(self, pos) -> int:
-        """
-        Returns level number at given position
-
-        Parameters
-        ----------
-        pos : level position given in python list index style which may be negative
-
-        Raises
-        ------
-        IndexError if pos is out of range
-        """
-        if pos < 0:
-            pos += self.nlevels
-            if pos < 0:
-                orig_pos = pos - self.nlevels
-                raise IndexError(
-                    f"Too many levels: Index has only {self.nlevels} levels,"
-                    f" {orig_pos} is not a valid level number"
-                )
-        # Note: levels are zero-based
-        elif pos >= self.nlevels:
-            raise IndexError(
-                f"Too many levels: Index has only {self.nlevels} levels, "
-                f"not {pos + 1}"
-            )
-        return pos
-
     def _get_level_number(self, level) -> int:
         count = self.names.count(level)
         if (count > 1) and not is_integer(level):
             raise ValueError(
                 f"The name {level} occurs multiple times, use a level number"
             )
         try:
-            level = self._get_level_number_by_label(level)
-        except KeyError:
+            level = self.names.index(level)
+        except ValueError:
             if not is_integer(level):
-                raise
-            level = self._get_level_number_by_position(level)
+                raise KeyError(f"Level {level} not found")
+            elif level < 0:
+                level += self.nlevels
+                if level < 0:
+                    orig_level = level - self.nlevels
+                    raise IndexError(
+                        f"Too many levels: Index has only {self.nlevels} levels,"
+                        f" {orig_level} is not a valid level number"
+                    )
+            # Note: levels are zero-based
+            elif level >= self.nlevels:
+                raise IndexError(
+                    f"Too many levels: Index has only {self.nlevels} levels, "
+                    f"not {level + 1}"
+                )
         return level
 
     _tuples = None
@@ -2193,35 +2171,18 @@ def swaplevel(self, i=-2, j=-1):
             levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False
         )
 
-    def reorder_levels(self, order, positional=None):
+    def reorder_levels(self, order):
         """
         Rearrange levels using input order. May not drop or duplicate levels.
 
         Parameters
         ----------
-        order : list
-            the order of index levels after reorder, could be level labels or positions
-        positional : bool, optional
-            How to interpret integer values in `order`.
-
-              * None (default): prefer treating the values as labels,
-                but fall back to positional if no label with that
-                value is value.
-              * True : only treat integer values as positions.
-              * False : only treat integer values as labels.
 
         Returns
         -------
         MultiIndex
         """
-        # GH30289
-        if positional is None:
-            order = [self._get_level_number(i) for i in order]
-        elif positional:
-            order = [self._get_level_number_by_position(i) for i in order]
-        else:
-            order = [self._get_level_number_by_label(i) for i in order]
-
+        order = [self._get_level_number(i) for i in order]
         if len(order) != self.nlevels:
             raise AssertionError(
                 f"Length of order must be same as number of levels ({self.nlevels}),"

pandas/tests/indexes/multi/test_drop.py

@@ -139,19 +139,3 @@ def test_drop_not_lexsorted():
     tm.assert_index_equal(lexsorted_mi, not_lexsorted_mi)
     with tm.assert_produces_warning(PerformanceWarning):
         tm.assert_index_equal(lexsorted_mi.drop("a"), not_lexsorted_mi.drop("a"))
-
-
-def test_drop_with_non_unique_datetime_index_and_invalid_keys():
-    # GH 30399
-
-    # define dataframe with unique datetime index
-    df = pd.DataFrame(
-        np.random.randn(5, 3),
-        columns=["a", "b", "c"],
-        index=pd.date_range("2012", freq="H", periods=5),
-    )
-    # create dataframe with non-unique datetime index
-    df = df.iloc[[0, 2, 2, 3]].copy()
-
-    with pytest.raises(KeyError, match="not found in axis"):
-        df.drop(["a", "b"])  # Dropping with labels not exist in the index