Merge branch 'master' of https://github.com/pandas-dev/pandas into ref-tests7

Author: jbrockmendel

.binstar.yml

@@ -121,7 +121,7 @@ conda list pandas
 # Make sure any error below is reported as such
 
 echo "[Build extensions]"
-python setup.py build_ext -q -i
+python setup.py build_ext -q -i -j2
 
 # XXX: Some of our environments end up with old versions of pip (10.x)
 # Adding a new enough version of pip to the requirements explodes the

ci/setup_env.sh

@@ -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/advanced.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/missing_data.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/user_guide/text.rst

@@ -10,7 +10,7 @@
     try:
         __import__(dependency)
     except ImportError as e:
-        missing_dependencies.append("{0}: {1}".format(dependency, str(e)))
+        missing_dependencies.append(f"{dependency}: {e}")
 
 if missing_dependencies:
     raise ImportError(
@@ -33,10 +33,10 @@
     # hack but overkill to use re
     module = str(e).replace("cannot import name ", "")
     raise ImportError(
-        "C extension: {0} not built. If you want to import "
+        f"C extension: {module} not built. If you want to import "
         "pandas from the source directory, you may need to run "
         "'python setup.py build_ext --inplace --force' to build "
-        "the C extensions first.".format(module)
+        "the C extensions first."
     )
 
 from datetime import datetime
@@ -213,16 +213,16 @@ class Panel:
             return Panel
         elif name in {"SparseSeries", "SparseDataFrame"}:
             warnings.warn(
-                "The {} class is removed from pandas. Accessing it from "
+                f"The {name} class is removed from pandas. Accessing it from "
                 "the top-level namespace will also be removed in the next "
-                "version".format(name),
+                "version",
                 FutureWarning,
                 stacklevel=2,
             )
 
             return type(name, (), {})
 
-        raise AttributeError("module 'pandas' has no attribute '{}'".format(name))
+        raise AttributeError(f"module 'pandas' has no attribute '{name}'")
 
 
 else:

doc/source/whatsnew/v1.0.0.rst

@@ -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/__init__.py

@@ -28,7 +28,7 @@ def unstack(reshape_t[:, :] values, uint8_t[:] mask,
             Py_ssize_t stride, Py_ssize_t length, Py_ssize_t width,
             reshape_t[:, :] new_values, uint8_t[:, :] new_mask):
     """
-    transform long sorted_values to wide new_values
+    Transform long values to wide new_values.
 
     Parameters
     ----------

pandas/_libs/intervaltree.pxi.in

@@ -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]