change a couple of sorting.py functions to be non-private (public to pandas internals)

jreback · jreback · commit fdcf9a17d926 · 2017-02-14T16:44:41.000-05:00
closes #15393
diff --git a/pandas/core/frame.py b/pandas/core/frame.py
@@ -3179,7 +3179,7 @@ def sort_values(self, by, axis=0, ascending=True, inplace=False,
             raise ValueError('Length of ascending (%d) != length of by (%d)' %
                              (len(ascending), len(by)))
         if len(by) > 1:
-            from pandas.core.sorting import _lexsort_indexer
+            from pandas.core.sorting import lexsort_indexer
 
             def trans(v):
                 if needs_i8_conversion(v):
@@ -3193,11 +3193,11 @@ def trans(v):
                     raise ValueError('Cannot sort by duplicate column %s' %
                                      str(x))
                 keys.append(trans(k))
-            indexer = _lexsort_indexer(keys, orders=ascending,
-                                       na_position=na_position)
+            indexer = lexsort_indexer(keys, orders=ascending,
+                                      na_position=na_position)
             indexer = _ensure_platform_int(indexer)
         else:
-            from pandas.core.sorting import _nargsort
+            from pandas.core.sorting import nargsort
 
             by = by[0]
             k = self.xs(by, axis=other_axis).values
@@ -3214,8 +3214,8 @@ def trans(v):
             if isinstance(ascending, (tuple, list)):
                 ascending = ascending[0]
 
-            indexer = _nargsort(k, kind=kind, ascending=ascending,
-                                na_position=na_position)
+            indexer = nargsort(k, kind=kind, ascending=ascending,
+                               na_position=na_position)
 
         new_data = self._data.take(indexer,
                                    axis=self._get_block_manager_axis(axis),
@@ -3300,17 +3300,17 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
                                                  sort_remaining=sort_remaining)
 
         elif isinstance(labels, MultiIndex):
-            from pandas.core.sorting import _lexsort_indexer
+            from pandas.core.sorting import lexsort_indexer
 
             # make sure that the axis is lexsorted to start
             # if not we need to reconstruct to get the correct indexer
             if not labels.is_lexsorted():
                 labels = MultiIndex.from_tuples(labels.values)
 
-            indexer = _lexsort_indexer(labels.labels, orders=ascending,
-                                       na_position=na_position)
+            indexer = lexsort_indexer(labels.labels, orders=ascending,
+                                      na_position=na_position)
         else:
-            from pandas.core.sorting import _nargsort
+            from pandas.core.sorting import nargsort
 
             # GH11080 - Check monotonic-ness before sort an index
             # if monotonic (already sorted), return None or copy() according
@@ -3322,8 +3322,8 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
                 else:
                     return self.copy()
 
-            indexer = _nargsort(labels, kind=kind, ascending=ascending,
-                                na_position=na_position)
+            indexer = nargsort(labels, kind=kind, ascending=ascending,
+                               na_position=na_position)
 
         new_data = self._data.take(indexer,
                                    axis=self._get_block_manager_axis(axis),
diff --git a/pandas/core/groupby.py b/pandas/core/groupby.py
@@ -47,9 +47,9 @@
 from pandas.core.internals import BlockManager, make_block
 from pandas.core.series import Series
 from pandas.core.panel import Panel
-from pandas.core.sorting import (_get_group_index_sorter, get_group_index,
-                                 _compress_group_index, _KeyMapper,
-                                 decons_obs_group_ids, _get_indices_dict)
+from pandas.core.sorting import (get_group_index_sorter, get_group_index,
+                                 compress_group_index, get_flattened_iterator,
+                                 decons_obs_group_ids, get_indexer_dict)
 from pandas.util.decorators import (cache_readonly, Substitution, Appender,
                                     make_signature, deprecate_kwarg)
 from pandas.formats.printing import pprint_thing
@@ -731,7 +731,7 @@ def _cumcount_array(self, ascending=True):
         (though the default is sort=True) for groupby in general
         """
         ids, _, ngroups = self.grouper.group_info
-        sorter = _get_group_index_sorter(ids, ngroups)
+        sorter = get_group_index_sorter(ids, ngroups)
         ids, count = ids[sorter], len(ids)
 
         if count == 0:
@@ -1618,9 +1618,12 @@ def _get_group_keys(self):
             return self.levels[0]
         else:
             comp_ids, _, ngroups = self.group_info
+
             # provide "flattened" iterator for multi-group setting
-            mapper = _KeyMapper(comp_ids, ngroups, self.labels, self.levels)
-            return [mapper.get_key(i) for i in range(ngroups)]
+            return get_flattened_iterator(comp_ids,
+                                          ngroups,
+                                          self.levels,
+                                          self.labels)
 
     def apply(self, f, data, axis=0):
         mutated = self.mutated
@@ -1664,7 +1667,7 @@ def indices(self):
             label_list = [ping.labels for ping in self.groupings]
             keys = [_values_from_object(ping.group_index)
                     for ping in self.groupings]
-            return _get_indices_dict(label_list, keys)
+            return get_indexer_dict(label_list, keys)
 
     @property
     def labels(self):
@@ -1728,7 +1731,7 @@ def _get_compressed_labels(self):
         if len(all_labels) > 1:
             group_index = get_group_index(all_labels, self.shape,
                                           sort=True, xnull=True)
-            return _compress_group_index(group_index, sort=self.sort)
+            return compress_group_index(group_index, sort=self.sort)
 
         ping = self.groupings[0]
         return ping.labels, np.arange(len(ping.group_index))
@@ -2029,7 +2032,7 @@ def _aggregate_series_fast(self, obj, func):
 
         # avoids object / Series creation overhead
         dummy = obj._get_values(slice(None, 0)).to_dense()
-        indexer = _get_group_index_sorter(group_index, ngroups)
+        indexer = get_group_index_sorter(group_index, ngroups)
         obj = obj.take(indexer, convert=False)
         group_index = algos.take_nd(group_index, indexer, allow_fill=False)
         grouper = lib.SeriesGrouper(obj, func, group_index, ngroups,
@@ -4207,7 +4210,7 @@ def slabels(self):
     @cache_readonly
     def sort_idx(self):
         # Counting sort indexer
-        return _get_group_index_sorter(self.labels, self.ngroups)
+        return get_group_index_sorter(self.labels, self.ngroups)
 
     def __iter__(self):
         sdata = self._get_sorted_data()
diff --git a/pandas/core/reshape.py b/pandas/core/reshape.py
@@ -20,7 +20,7 @@
 from pandas._sparse import IntIndex
 
 from pandas.core.categorical import Categorical, _factorize_from_iterable
-from pandas.core.sorting import (get_group_index, _compress_group_index,
+from pandas.core.sorting import (get_group_index, compress_group_index,
                                  decons_obs_group_ids)
 
 import pandas.core.algorithms as algos
@@ -157,7 +157,7 @@ def get_result(self):
 
         # filter out missing levels
         if values.shape[1] > 0:
-            col_inds, obs_ids = _compress_group_index(self.sorted_labels[-1])
+            col_inds, obs_ids = compress_group_index(self.sorted_labels[-1])
             # rare case, level values not observed
             if len(obs_ids) < self.full_shape[1]:
                 inds = (value_mask.sum(0) > 0).nonzero()[0]
@@ -267,7 +267,7 @@ def _unstack_multiple(data, clocs):
     shape = [len(x) for x in clevels]
     group_index = get_group_index(clabels, shape, sort=False, xnull=False)
 
-    comp_ids, obs_ids = _compress_group_index(group_index, sort=False)
+    comp_ids, obs_ids = compress_group_index(group_index, sort=False)
     recons_labels = decons_obs_group_ids(comp_ids, obs_ids, shape, clabels,
                                          xnull=False)
 
@@ -459,7 +459,7 @@ def _unstack_frame(obj, level, fill_value=None):
 
 def get_compressed_ids(labels, sizes):
     ids = get_group_index(labels, sizes, sort=True, xnull=False)
-    return _compress_group_index(ids, sort=True)
+    return compress_group_index(ids, sort=True)
 
 
 def stack(frame, level=-1, dropna=True):
diff --git a/pandas/core/series.py b/pandas/core/series.py
@@ -1786,12 +1786,12 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
             new_index, indexer = index.sortlevel(level, ascending=ascending,
                                                  sort_remaining=sort_remaining)
         elif isinstance(index, MultiIndex):
-            from pandas.core.sorting import _lexsort_indexer
-            indexer = _lexsort_indexer(index.labels, orders=ascending)
+            from pandas.core.sorting import lexsort_indexer
+            indexer = lexsort_indexer(index.labels, orders=ascending)
         else:
-            from pandas.core.sorting import _nargsort
-            indexer = _nargsort(index, kind=kind, ascending=ascending,
-                                na_position=na_position)
+            from pandas.core.sorting import nargsort
+            indexer = nargsort(index, kind=kind, ascending=ascending,
+                               na_position=na_position)
 
         indexer = _ensure_platform_int(indexer)
         new_index = index.take(indexer)
diff --git a/pandas/core/sorting.py b/pandas/core/sorting.py
@@ -13,6 +13,9 @@
 from pandas import lib
 
 
+_INT64_MAX = np.iinfo(np.int64).max
+
+
 def get_group_index(labels, shape, sort, xnull):
     """
     For the particular label_list, gets the offsets into the hypothetical list
@@ -74,7 +77,7 @@ def loop(labels, shape):
 
         # compress what has been done so far in order to avoid overflow
         # to retain lexical ranks, obs_ids should be sorted
-        comp_ids, obs_ids = _compress_group_index(out, sort=sort)
+        comp_ids, obs_ids = compress_group_index(out, sort=sort)
 
         labels = [comp_ids] + labels[nlev:]
         shape = [len(obs_ids)] + shape[nlev:]
@@ -91,10 +94,7 @@ def maybe_lift(lab, size):  # pormote nan values
     return loop(list(labels), list(shape))
 
 
-_INT64_MAX = np.iinfo(np.int64).max
-
-
-def _int64_overflow_possible(shape):
+def is_int64_overflow_possible(shape):
     the_prod = long(1)
     for x in shape:
         the_prod *= long(x)
@@ -104,7 +104,7 @@ def _int64_overflow_possible(shape):
 
 def decons_group_index(comp_labels, shape):
     # reconstruct labels
-    if _int64_overflow_possible(shape):
+    if is_int64_overflow_possible(shape):
         # at some point group indices are factorized,
         # and may not be deconstructed here! wrong path!
         raise ValueError('cannot deconstruct factorized group indices!')
@@ -137,7 +137,7 @@ def decons_obs_group_ids(comp_ids, obs_ids, shape, labels, xnull):
         lift = np.fromiter(((a == -1).any() for a in labels), dtype='i8')
         shape = np.asarray(shape, dtype='i8') + lift
 
-    if not _int64_overflow_possible(shape):
+    if not is_int64_overflow_possible(shape):
         # obs ids are deconstructable! take the fast route!
         out = decons_group_index(obs_ids, shape)
         return out if xnull or not lift.any() \
@@ -148,19 +148,19 @@ def decons_obs_group_ids(comp_ids, obs_ids, shape, labels, xnull):
     return [i8copy(lab[i]) for lab in labels]
 
 
-def _indexer_from_factorized(labels, shape, compress=True):
+def indexer_from_factorized(labels, shape, compress=True):
     ids = get_group_index(labels, shape, sort=True, xnull=False)
 
     if not compress:
         ngroups = (ids.size and ids.max()) + 1
     else:
-        ids, obs = _compress_group_index(ids, sort=True)
+        ids, obs = compress_group_index(ids, sort=True)
         ngroups = len(obs)
 
-    return _get_group_index_sorter(ids, ngroups)
+    return get_group_index_sorter(ids, ngroups)
 
 
-def _lexsort_indexer(keys, orders=None, na_position='last'):
+def lexsort_indexer(keys, orders=None, na_position='last'):
     labels = []
     shape = []
     if isinstance(orders, bool):
@@ -201,10 +201,10 @@ def _lexsort_indexer(keys, orders=None, na_position='last'):
         shape.append(n)
         labels.append(codes)
 
-    return _indexer_from_factorized(labels, shape)
+    return indexer_from_factorized(labels, shape)
 
 
-def _nargsort(items, kind='quicksort', ascending=True, na_position='last'):
+def nargsort(items, kind='quicksort', ascending=True, na_position='last'):
     """
     This is intended to be a drop-in replacement for np.argsort which
     handles NaNs. It adds ascending and na_position parameters.
@@ -244,7 +244,7 @@ class _KeyMapper(object):
     Ease my suffering. Map compressed group id -> key tuple
     """
 
-    def __init__(self, comp_ids, ngroups, labels, levels):
+    def __init__(self, comp_ids, ngroups, levels, labels):
         self.levels = levels
         self.labels = labels
         self.comp_ids = comp_ids.astype(np.int64)
@@ -263,15 +263,22 @@ def get_key(self, comp_id):
                      for table, level in zip(self.tables, self.levels))
 
 
-def _get_indices_dict(label_list, keys):
+def get_flattened_iterator(comp_ids, ngroups, levels, labels):
+    # provide "flattened" iterator for multi-group setting
+    mapper = _KeyMapper(comp_ids, ngroups, levels, labels)
+    return [mapper.get_key(i) for i in range(ngroups)]
+
+
+def get_indexer_dict(label_list, keys):
+    """ return a diction of {labels} -> {indexers} """
     shape = list(map(len, keys))
 
     group_index = get_group_index(label_list, shape, sort=True, xnull=True)
     ngroups = ((group_index.size and group_index.max()) + 1) \
-        if _int64_overflow_possible(shape) \
+        if is_int64_overflow_possible(shape) \
         else np.prod(shape, dtype='i8')
 
-    sorter = _get_group_index_sorter(group_index, ngroups)
+    sorter = get_group_index_sorter(group_index, ngroups)
 
     sorted_labels = [lab.take(sorter) for lab in label_list]
     group_index = group_index.take(sorter)
@@ -282,7 +289,7 @@ def _get_indices_dict(label_list, keys):
 # ----------------------------------------------------------------------
 # sorting levels...cleverly?
 
-def _get_group_index_sorter(group_index, ngroups):
+def get_group_index_sorter(group_index, ngroups):
     """
     _algos.groupsort_indexer implements `counting sort` and it is at least
     O(ngroups), where
@@ -309,7 +316,7 @@ def _get_group_index_sorter(group_index, ngroups):
         return group_index.argsort(kind='mergesort')
 
 
-def _compress_group_index(group_index, sort=True):
+def compress_group_index(group_index, sort=True):
     """
     Group_index is offsets into cartesian product of all possible labels. This
     space can be huge, so this function compresses it, by computing offsets
diff --git a/pandas/indexes/multi.py b/pandas/indexes/multi.py
@@ -1405,7 +1405,7 @@ def sortlevel(self, level=0, ascending=True, sort_remaining=True):
             Indices of output values in original index
 
         """
-        from pandas.core.sorting import _indexer_from_factorized
+        from pandas.core.sorting import indexer_from_factorized
 
         if isinstance(level, (compat.string_types, int)):
             level = [level]
@@ -1417,8 +1417,8 @@ def sortlevel(self, level=0, ascending=True, sort_remaining=True):
             if not len(level) == len(ascending):
                 raise ValueError("level must have same length as ascending")
 
-            from pandas.core.sorting import _lexsort_indexer
-            indexer = _lexsort_indexer(self.labels, orders=ascending)
+            from pandas.core.sorting import lexsort_indexer
+            indexer = lexsort_indexer(self.labels, orders=ascending)
 
         # level ordering
         else:
@@ -1436,8 +1436,8 @@ def sortlevel(self, level=0, ascending=True, sort_remaining=True):
             else:
                 sortorder = level[0]
 
-            indexer = _indexer_from_factorized(primary, primshp,
-                                               compress=False)
+            indexer = indexer_from_factorized(primary, primshp,
+                                              compress=False)
 
             if not ascending:
                 indexer = indexer[::-1]
diff --git a/pandas/tests/test_sorting.py b/pandas/tests/test_sorting.py
diff --git a/pandas/tools/merge.py b/pandas/tools/merge.py
