Merge pull request #1 from pandas-dev/master

Sync

Author: naomi172839

doc/source/user_guide/advanced.rst

@@ -573,7 +573,7 @@ When working with an ``Index`` object directly, rather than via a ``DataFrame``,
    .. code-block:: none
 
       >>> mi.levels[0].name = 'name via level'
-      >>> mi.names[0]  # only works for older panads
+      >>> mi.names[0]  # only works for older pandas
       'name via level'
 
    As of pandas 1.0, this will *silently* fail to update the names

doc/source/user_guide/missing_data.rst

@@ -791,7 +791,7 @@ the nullable :doc:`integer <integer_na>`, boolean and
 :ref:`dedicated string <text.types>` data types as the missing value indicator.
 
 The goal of ``pd.NA`` is provide a "missing" indicator that can be used
-consistently accross data types (instead of ``np.nan``, ``None`` or ``pd.NaT``
+consistently across data types (instead of ``np.nan``, ``None`` or ``pd.NaT``
 depending on the data type).
 
 For example, when having missing values in a Series with the nullable integer

doc/source/user_guide/text.rst

@@ -101,10 +101,10 @@ l. For ``StringDtype``, :ref:`string accessor methods<api.series.str>`
 2. Some string methods, like :meth:`Series.str.decode` are not available
    on ``StringArray`` because ``StringArray`` only holds strings, not
    bytes.
-3. In comparision operations, :class:`arrays.StringArray` and ``Series`` backed
+3. In comparison operations, :class:`arrays.StringArray` and ``Series`` backed
    by a ``StringArray`` will return an object with :class:`BooleanDtype`,
    rather than a ``bool`` dtype object. Missing values in a ``StringArray``
-   will propagate in comparision operations, rather than always comparing
+   will propagate in comparison operations, rather than always comparing
    unequal like :attr:`numpy.nan`.
 
 Everything else that follows in the rest of this document applies equally to

doc/source/whatsnew/v1.0.0.rst

@@ -111,7 +111,7 @@ A new ``pd.NA`` value (singleton) is introduced to represent scalar missing
 values. Up to now, ``np.nan`` is used for this for float data, ``np.nan`` or
 ``None`` for object-dtype data and ``pd.NaT`` for datetime-like data. The
 goal of ``pd.NA`` is provide a "missing" indicator that can be used
-consistently accross data types. For now, the nullable integer and boolean
+consistently across data types. For now, the nullable integer and boolean
 data types and the new string data type make use of ``pd.NA`` (:issue:`28095`).
 
 .. warning::
@@ -826,7 +826,7 @@ Plotting
 - Bug where :meth:`DataFrame.boxplot` would not accept a `color` parameter like `DataFrame.plot.box` (:issue:`26214`)
 - Bug in the ``xticks`` argument being ignored for :meth:`DataFrame.plot.bar` (:issue:`14119`)
 - :func:`set_option` now validates that the plot backend provided to ``'plotting.backend'`` implements the backend when the option is set, rather than when a plot is created (:issue:`28163`)
-- :meth:`DataFrame.plot` now allow a ``backend`` keyword arugment to allow changing between backends in one session (:issue:`28619`).
+- :meth:`DataFrame.plot` now allow a ``backend`` keyword argument to allow changing between backends in one session (:issue:`28619`).
 - Bug in color validation incorrectly raising for non-color styles (:issue:`29122`).
 
 Groupby/resample/rolling

pandas/_libs/intervaltree.pxi.in

@@ -114,43 +114,6 @@ cdef class IntervalTree(IntervalMixin):
         sort_order = np.lexsort(values)
         return is_monotonic(sort_order, False)[0]
 
-    def get_loc(self, scalar_t key):
-        """Return all positions corresponding to intervals that overlap with
-        the given scalar key
-        """
-        result = Int64Vector()
-        self.root.query(result, key)
-        if not result.data.n:
-            raise KeyError(key)
-        return result.to_array().astype('intp')
-
-    def _get_partial_overlap(self, key_left, key_right, side):
-        """Return all positions corresponding to intervals with the given side
-        falling between the left and right bounds of an interval query
-        """
-        if side == 'left':
-            values = self.left
-            sorter = self.left_sorter
-        else:
-            values = self.right
-            sorter = self.right_sorter
-        key = [key_left, key_right]
-        i, j = values.searchsorted(key, sorter=sorter)
-        return sorter[i:j]
-
-    def get_loc_interval(self, key_left, key_right):
-        """Lookup the intervals enclosed in the given interval bounds
-
-        The given interval is presumed to have closed bounds.
-        """
-        import pandas as pd
-        left_overlap = self._get_partial_overlap(key_left, key_right, 'left')
-        right_overlap = self._get_partial_overlap(key_left, key_right, 'right')
-        enclosing = self.get_loc(0.5 * (key_left + key_right))
-        combined = np.concatenate([left_overlap, right_overlap, enclosing])
-        uniques = pd.unique(combined)
-        return uniques.astype('intp')
-
     def get_indexer(self, scalar_t[:] target):
         """Return the positions corresponding to unique intervals that overlap
         with the given array of scalar targets.

pandas/core/arrays/datetimelike.py

@@ -915,7 +915,7 @@ def _is_unique(self):
     __rdivmod__ = make_invalid_op("__rdivmod__")
 
     def _add_datetimelike_scalar(self, other):
-        # Overriden by TimedeltaArray
+        # Overridden by TimedeltaArray
         raise TypeError(f"cannot add {type(self).__name__} and {type(other).__name__}")
 
     _add_datetime_arraylike = _add_datetimelike_scalar
@@ -928,7 +928,7 @@ def _sub_datetimelike_scalar(self, other):
     _sub_datetime_arraylike = _sub_datetimelike_scalar
 
     def _sub_period(self, other):
-        # Overriden by PeriodArray
+        # Overridden by PeriodArray
         raise TypeError(f"cannot subtract Period from a {type(self).__name__}")
 
     def _add_offset(self, offset):
@@ -1085,7 +1085,7 @@ def _addsub_int_array(self, other, op):
         -------
         result : same class as self
         """
-        # _addsub_int_array is overriden by PeriodArray
+        # _addsub_int_array is overridden by PeriodArray
         assert not is_period_dtype(self)
         assert op in [operator.add, operator.sub]
 

pandas/core/groupby/groupby.py

@@ -4,7 +4,7 @@ class providing the base-class of operations.
 
 The SeriesGroupBy and DataFrameGroupBy sub-class
 (defined in pandas.core.groupby.generic)
-expose these user-facing objects to provide specific functionailty.
+expose these user-facing objects to provide specific functionality.
 """
 
 from contextlib import contextmanager

pandas/core/indexes/interval.py

@@ -978,7 +978,7 @@ def get_indexer(
             right_indexer = self.right.get_indexer(target_as_index.right)
             indexer = np.where(left_indexer == right_indexer, left_indexer, -1)
         elif is_categorical(target_as_index):
-            # get an indexer for unique categories then propogate to codes via take_1d
+            # get an indexer for unique categories then propagate to codes via take_1d
             categories_indexer = self.get_indexer(target_as_index.categories)
             indexer = take_1d(categories_indexer, target_as_index.codes, fill_value=-1)
         elif not is_object_dtype(target_as_index):

pandas/core/internals/blocks.py

@@ -1449,7 +1449,7 @@ def quantile(self, qs, interpolation="linear", axis=0):
         -------
         Block
         """
-        # We should always have ndim == 2 becase Series dispatches to DataFrame
+        # We should always have ndim == 2 because Series dispatches to DataFrame
         assert self.ndim == 2
 
         values = self.get_values()
@@ -2432,7 +2432,7 @@ def fillna(self, value, **kwargs):
             # Deprecation GH#24694, GH#19233
             raise TypeError(
                 "Passing integers to fillna for timedelta64[ns] dtype is no "
-                "longer supporetd.  To obtain the old behavior, pass "
+                "longer supported.  To obtain the old behavior, pass "
                 "`pd.Timedelta(seconds=n)` instead."
             )
         return super().fillna(value, **kwargs)
@@ -2971,7 +2971,7 @@ def make_block(values, placement, klass=None, ndim=None, dtype=None):
 
 
 def _extend_blocks(result, blocks=None):
-    """ return a new extended blocks, givin the result """
+    """ return a new extended blocks, given the result """
     from pandas.core.internals import BlockManager
 
     if blocks is None:

pandas/core/nanops.py

@@ -1337,7 +1337,7 @@ def f(x, y):
 
 def _nanpercentile_1d(values, mask, q, na_value, interpolation):
     """
-    Wraper for np.percentile that skips missing values, specialized to
+    Wrapper for np.percentile that skips missing values, specialized to
     1-dimensional case.
 
     Parameters
@@ -1368,7 +1368,7 @@ def _nanpercentile_1d(values, mask, q, na_value, interpolation):
 
 def nanpercentile(values, q, axis, na_value, mask, ndim, interpolation):
     """
-    Wraper for np.percentile that skips missing values.
+    Wrapper for np.percentile that skips missing values.
 
     Parameters
     ----------

pandas/core/series.py

@@ -727,7 +727,7 @@ def __array__(self, dtype=None):
                Timestamp('2000-01-02 00:00:00+0100', tz='CET', freq='D')],
               dtype=object)
 
-        Or the values may be localized to UTC and the tzinfo discared with
+        Or the values may be localized to UTC and the tzinfo discarded with
         ``dtype='datetime64[ns]'``
 
         >>> np.asarray(tzser, dtype="datetime64[ns]")  # doctest: +ELLIPSIS