CLN: move diff, take to algorithms.py

Author: jreback

pandas/core/algorithms.py

@@ -7,7 +7,7 @@
 from pandas import compat, lib
 from pandas.compat import u
 
-from pandas.core.algorithms import factorize
+from pandas.core.algorithms import factorize, take_1d
 from pandas.core.base import (PandasObject, PandasDelegate,
                               NoNewAttributesMixin, _shared_docs)
 import pandas.core.common as com
@@ -20,7 +20,7 @@
     is_dtype_equal, is_categorical_dtype, is_integer_dtype,
     _possibly_infer_to_datetimelike, get_dtype_kinds, is_list_like,
     is_sequence, is_null_slice, is_bool, _ensure_object, _ensure_int64,
-    _coerce_indexer_dtype, take_1d)
+    _coerce_indexer_dtype)
 from pandas.types.api import CategoricalDtype
 from pandas.util.terminal import get_terminal_size
 from pandas.core.config import get_option

pandas/core/categorical.py

@@ -39,6 +39,7 @@
 from pandas.core.series import Series
 from pandas.core.categorical import Categorical
 import pandas.computation.expressions as expressions
+import pandas.core.algorithms as algos
 from pandas.computation.eval import eval as _eval
 from pandas.compat import (range, map, zip, lrange, lmap, lzip, StringIO, u,
                            OrderedDict, raise_with_traceback)
@@ -2709,8 +2710,8 @@ def _reindex_multi(self, axes, copy, fill_value):
 
         if row_indexer is not None and col_indexer is not None:
             indexer = row_indexer, col_indexer
-            new_values = com.take_2d_multi(self.values, indexer,
-                                           fill_value=fill_value)
+            new_values = algos.take_2d_multi(self.values, indexer,
+                                             fill_value=fill_value)
             return self._constructor(new_values, index=new_index,
                                      columns=new_columns)
         else:
@@ -3084,11 +3085,11 @@ def duplicated(self, subset=None, keep='first'):
         duplicated : Series
         """
         from pandas.core.groupby import get_group_index
-        from pandas.core.algorithms import factorize
         from pandas.hashtable import duplicated_int64, _SIZE_HINT_LIMIT
 
         def f(vals):
-            labels, shape = factorize(vals, size_hint=min(len(self),
+            labels, shape = algos.factorize(vals,
+                                            size_hint=min(len(self),
                                                           _SIZE_HINT_LIMIT))
             return labels.astype('i8', copy=False), len(shape)
 
@@ -5436,7 +5437,7 @@ def _list_of_series_to_arrays(data, columns, coerce_float=False, dtype=None):
             indexer = indexer_cache[id(index)] = index.get_indexer(columns)
 
         values = _values_from_object(s)
-        aligned_values.append(com.take_1d(values, indexer))
+        aligned_values.append(algos.take_1d(values, indexer))
 
     values = np.vstack(aligned_values)
 

pandas/core/common.py

@@ -1351,7 +1351,7 @@ def shift(self, periods=1, freq=None, axis=0):
 
         output = {}
         for name, obj in self._iterate_slices():
-            output[name] = com.take_nd(obj.values, indexer)
+            output[name] = algos.take_nd(obj.values, indexer)
 
         return self._wrap_transformed_output(output)
 
@@ -1873,7 +1873,7 @@ def _aggregate_series_fast(self, obj, func):
         dummy = obj._get_values(slice(None, 0)).to_dense()
         indexer = _get_group_index_sorter(group_index, ngroups)
         obj = obj.take(indexer, convert=False)
-        group_index = com.take_nd(group_index, indexer, allow_fill=False)
+        group_index = algos.take_nd(group_index, indexer, allow_fill=False)
         grouper = lib.SeriesGrouper(obj, func, group_index, ngroups,
                                     dummy)
         result, counts = grouper.get_result()
@@ -3850,7 +3850,7 @@ def __init__(self, data, labels, ngroups, axis=0):
     @cache_readonly
     def slabels(self):
         # Sorted labels
-        return com.take_nd(self.labels, self.sort_idx, allow_fill=False)
+        return algos.take_nd(self.labels, self.sort_idx, allow_fill=False)
 
     @cache_readonly
     def sort_idx(self):
@@ -4278,11 +4278,11 @@ def _reorder_by_uniques(uniques, labels):
     mask = labels < 0
 
     # move labels to right locations (ie, unsort ascending labels)
-    labels = com.take_nd(reverse_indexer, labels, allow_fill=False)
+    labels = algos.take_nd(reverse_indexer, labels, allow_fill=False)
     np.putmask(labels, mask, -1)
 
     # sort observed ids
-    uniques = com.take_nd(uniques, sorter, allow_fill=False)
+    uniques = algos.take_nd(uniques, sorter, allow_fill=False)
 
     return uniques, labels
 

pandas/core/frame.py

@@ -20,6 +20,7 @@
                                 _maybe_convert_string_to_object,
                                 is_categorical, is_datetimelike_v_numeric,
                                 is_numeric_v_string_like, is_internal_type)
+import pandas.core.algorithms as algos
 from pandas.types.api import DatetimeTZDtype
 
 from pandas.core.index import Index, MultiIndex, _ensure_index
@@ -286,8 +287,8 @@ def reindex_axis(self, indexer, method=None, axis=1, fill_value=None,
         if fill_value is None:
             fill_value = self.fill_value
 
-        new_values = com.take_nd(self.values, indexer, axis,
-                                 fill_value=fill_value, mask_info=mask_info)
+        new_values = algos.take_nd(self.values, indexer, axis,
+                                   fill_value=fill_value, mask_info=mask_info)
         return self.make_block(new_values, fastpath=True)
 
     def get(self, item):
@@ -974,7 +975,7 @@ def take_nd(self, indexer, axis, new_mgr_locs=None, fill_tuple=None):
 
         """
 
-        # com.take_nd dispatches for DatetimeTZBlock, CategoricalBlock
+        # algos.take_nd dispatches for DatetimeTZBlock, CategoricalBlock
         # so need to preserve types
         # sparse is treated like an ndarray, but needs .get_values() shaping
 
@@ -984,12 +985,12 @@ def take_nd(self, indexer, axis, new_mgr_locs=None, fill_tuple=None):
 
         if fill_tuple is None:
             fill_value = self.fill_value
-            new_values = com.take_nd(values, indexer, axis=axis,
-                                     allow_fill=False)
+            new_values = algos.take_nd(values, indexer, axis=axis,
+                                       allow_fill=False)
         else:
             fill_value = fill_tuple[0]
-            new_values = com.take_nd(values, indexer, axis=axis,
-                                     allow_fill=True, fill_value=fill_value)
+            new_values = algos.take_nd(values, indexer, axis=axis,
+                                       allow_fill=True, fill_value=fill_value)
 
         if new_mgr_locs is None:
             if axis == 0:
@@ -1008,7 +1009,7 @@ def take_nd(self, indexer, axis, new_mgr_locs=None, fill_tuple=None):
 
     def diff(self, n, axis=1, mgr=None):
         """ return block for the diff of the values """
-        new_values = com.diff(self.values, n, axis=axis)
+        new_values = algos.diff(self.values, n, axis=axis)
         return [self.make_block(values=new_values, fastpath=True)]
 
     def shift(self, periods, axis=0, mgr=None):
@@ -2711,11 +2712,11 @@ def get_ftype_counts(self):
 
     def get_dtypes(self):
         dtypes = np.array([blk.dtype for blk in self.blocks])
-        return com.take_1d(dtypes, self._blknos, allow_fill=False)
+        return algos.take_1d(dtypes, self._blknos, allow_fill=False)
 
     def get_ftypes(self):
         ftypes = np.array([blk.ftype for blk in self.blocks])
-        return com.take_1d(ftypes, self._blknos, allow_fill=False)
+        return algos.take_1d(ftypes, self._blknos, allow_fill=False)
 
     def __getstate__(self):
         block_values = [b.values for b in self.blocks]
@@ -3070,8 +3071,8 @@ def combine(self, blocks, copy=True):
         new_blocks = []
         for b in blocks:
             b = b.copy(deep=copy)
-            b.mgr_locs = com.take_1d(inv_indexer, b.mgr_locs.as_array, axis=0,
-                                     allow_fill=False)
+            b.mgr_locs = algos.take_1d(inv_indexer, b.mgr_locs.as_array,
+                                       axis=0, allow_fill=False)
             new_blocks.append(b)
 
         new_axes = list(self.axes)
@@ -3451,8 +3452,8 @@ def value_getitem(placement):
             new_blknos.fill(-1)
             new_blknos[~is_deleted] = np.arange(self.nblocks -
                                                 len(removed_blknos))
-            self._blknos = com.take_1d(new_blknos, self._blknos, axis=0,
-                                       allow_fill=False)
+            self._blknos = algos.take_1d(new_blknos, self._blknos, axis=0,
+                                         allow_fill=False)
             self.blocks = tuple(blk for i, blk in enumerate(self.blocks)
                                 if i not in set(removed_blknos))
 
@@ -3632,10 +3633,10 @@ def _slice_take_blocks_ax0(self, slice_or_indexer, fill_tuple=None):
             blknos = self._blknos[slobj]
             blklocs = self._blklocs[slobj]
         else:
-            blknos = com.take_1d(self._blknos, slobj, fill_value=-1,
-                                 allow_fill=allow_fill)
-            blklocs = com.take_1d(self._blklocs, slobj, fill_value=-1,
-                                  allow_fill=allow_fill)
+            blknos = algos.take_1d(self._blknos, slobj, fill_value=-1,
+                                   allow_fill=allow_fill)
+            blklocs = algos.take_1d(self._blklocs, slobj, fill_value=-1,
+                                    allow_fill=allow_fill)
 
         # When filling blknos, make sure blknos is updated before appending to
         # blocks list, that way new blkno is exactly len(blocks).
@@ -3847,7 +3848,7 @@ def reindex(self, new_axis, indexer=None, method=None, fill_value=None,
             else:
                 fill_value = np.nan
 
-        new_values = com.take_1d(values, indexer, fill_value=fill_value)
+        new_values = algos.take_1d(values, indexer, fill_value=fill_value)
 
         # fill if needed
         if method is not None or limit is not None:
@@ -4676,8 +4677,8 @@ def get_mgr_concatenation_plan(mgr, indexers):
 
     if 0 in indexers:
         ax0_indexer = indexers.pop(0)
-        blknos = com.take_1d(mgr._blknos, ax0_indexer, fill_value=-1)
-        blklocs = com.take_1d(mgr._blklocs, ax0_indexer, fill_value=-1)
+        blknos = algos.take_1d(mgr._blknos, ax0_indexer, fill_value=-1)
+        blklocs = algos.take_1d(mgr._blklocs, ax0_indexer, fill_value=-1)
     else:
 
         if mgr._is_single_block:
@@ -4932,8 +4933,8 @@ def get_reindexed_values(self, empty_dtype, upcasted_na):
 
         else:
             for ax, indexer in self.indexers.items():
-                values = com.take_nd(values, indexer, axis=ax,
-                                     fill_value=fill_value)
+                values = algos.take_nd(values, indexer, axis=ax,
+                                       fill_value=fill_value)
 
         return values
 

pandas/core/groupby.py

@@ -19,6 +19,7 @@
 from pandas.tslib import iNaT
 from pandas.compat import bind_method
 import pandas.core.missing as missing
+import pandas.core.algorithms as algos
 from pandas.core.common import (is_list_like, notnull, isnull,
                                 _values_from_object, _maybe_match_name,
                                 needs_i8_conversion, is_datetimelike_v_numeric,
@@ -632,10 +633,10 @@ def wrapper(left, right, name=name, na_op=na_op):
                                                     return_indexers=True)
 
                 if lidx is not None:
-                    lvalues = com.take_1d(lvalues, lidx)
+                    lvalues = algos.take_1d(lvalues, lidx)
 
                 if ridx is not None:
-                    rvalues = com.take_1d(rvalues, ridx)
+                    rvalues = algos.take_1d(rvalues, ridx)
 
             arr = na_op(lvalues, rvalues)
 

pandas/core/internals.py

@@ -18,7 +18,8 @@
 from pandas.core.groupby import get_group_index, _compress_group_index
 
 import pandas.core.common as com
-import pandas.algos as algos
+import pandas.core.algorithms as algos
+import pandas.algos as _algos
 
 from pandas.core.index import MultiIndex, _get_na_value
 
@@ -109,10 +110,10 @@ def _make_sorted_values_labels(self):
         comp_index, obs_ids = get_compressed_ids(to_sort, sizes)
         ngroups = len(obs_ids)
 
-        indexer = algos.groupsort_indexer(comp_index, ngroups)[0]
+        indexer = _algos.groupsort_indexer(comp_index, ngroups)[0]
         indexer = _ensure_platform_int(indexer)
 
-        self.sorted_values = com.take_nd(self.values, indexer, axis=0)
+        self.sorted_values = algos.take_nd(self.values, indexer, axis=0)
         self.sorted_labels = [l.take(indexer) for l in to_sort]
 
     def _make_selectors(self):
@@ -155,7 +156,7 @@ def get_result(self):
             # rare case, level values not observed
             if len(obs_ids) < self.full_shape[1]:
                 inds = (value_mask.sum(0) > 0).nonzero()[0]
-                values = com.take_nd(values, inds, axis=1)
+                values = algos.take_nd(values, inds, axis=1)
                 columns = columns[inds]
 
         # may need to coerce categoricals here

pandas/core/ops.py

@@ -44,7 +44,7 @@
 
 
 import pandas.core.ops as ops
-from pandas.core import algorithms
+import pandas.core.algorithms as algos
 
 import pandas.core.common as com
 import pandas.core.datetools as datetools
@@ -1202,7 +1202,7 @@ def mode(self):
         modes : Series (sorted)
         """
         # TODO: Add option for bins like value_counts()
-        return algorithms.mode(self)
+        return algos.mode(self)
 
     @deprecate_kwarg('take_last', 'keep', mapping={True: 'last',
                                                    False: 'first'})
@@ -1424,7 +1424,7 @@ def diff(self, periods=1):
         -------
         diffed : Series
         """
-        result = com.diff(_values_from_object(self), periods)
+        result = algos.diff(_values_from_object(self), periods)
         return self._constructor(result, index=self.index).__finalize__(self)
 
     def autocorr(self, lag=1):
@@ -1889,7 +1889,7 @@ def nlargest(self, n=5, keep='first'):
         >>> s = pd.Series(np.random.randn(1e6))
         >>> s.nlargest(10)  # only sorts up to the N requested
         """
-        return algorithms.select_n(self, n=n, keep=keep, method='nlargest')
+        return algos.select_n(self, n=n, keep=keep, method='nlargest')
 
     @deprecate_kwarg('take_last', 'keep', mapping={True: 'last',
                                                    False: 'first'})
@@ -1927,7 +1927,7 @@ def nsmallest(self, n=5, keep='first'):
         >>> s = pd.Series(np.random.randn(1e6))
         >>> s.nsmallest(10)  # only sorts up to the N requested
         """
-        return algorithms.select_n(self, n=n, keep=keep, method='nsmallest')
+        return algos.select_n(self, n=n, keep=keep, method='nsmallest')
 
     def sortlevel(self, level=0, ascending=True, sort_remaining=True):
         """
@@ -2081,7 +2081,7 @@ def map_f(values, f):
                 arg = self._constructor(arg, index=arg.keys())
 
             indexer = arg.index.get_indexer(values)
-            new_values = com.take_1d(arg._values, indexer)
+            new_values = algos.take_1d(arg._values, indexer)
             return self._constructor(new_values,
                                      index=self.index).__finalize__(self)
         else:
@@ -2233,7 +2233,7 @@ def _reindex_indexer(self, new_index, indexer, copy):
             return self
 
         # be subclass-friendly
-        new_values = com.take_1d(self.get_values(), indexer)
+        new_values = algos.take_1d(self.get_values(), indexer)
         return self._constructor(new_values, index=new_index)
 
     def _needs_reindex_multi(self, axes, method, level):
@@ -2384,7 +2384,7 @@ def isin(self, values):
         dtype: bool
 
         """
-        result = algorithms.isin(_values_from_object(self), values)
+        result = algos.isin(_values_from_object(self), values)
         return self._constructor(result, index=self.index).__finalize__(self)
 
     def between(self, left, right, inclusive=True):
@@ -2627,7 +2627,7 @@ def asof(self, where):
             where = Index(where)
 
         locs = self.index.asof_locs(where, notnull(values))
-        new_values = com.take_1d(values, locs)
+        new_values = algos.take_1d(values, locs)
         return self._constructor(new_values, index=where).__finalize__(self)
 
     def to_timestamp(self, freq=None, how='start', copy=True):

pandas/core/reshape.py

@@ -4,7 +4,8 @@
 from pandas.core.common import (isnull, notnull, _values_from_object,
                                 is_bool_dtype,
                                 is_list_like, is_categorical_dtype,
-                                is_object_dtype, take_1d)
+                                is_object_dtype)
+from pandas.core.algorithms import take_1d
 import pandas.compat as compat
 from pandas.core.base import AccessorProperty, NoNewAttributesMixin
 from pandas.util.decorators import Appender, deprecate_kwarg