Merge branch 'master' of https://github.com/pandas-dev/pandas into op…

…s-kwargs9

.travis.yml

@@ -73,6 +73,10 @@ matrix:
       env:
         - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
     # In allow_failures
+    - dist: trusty
+      env:
+        - JOB="3.6_ASV" ASV=true
+    # In allow_failures
     - dist: trusty
       env:
         - JOB="3.6_DOC" DOC=true
@@ -93,6 +97,9 @@ matrix:
       - dist: trusty
         env:
           - JOB="3.6_NUMPY_DEV" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate"
+      - dist: trusty
+        env:
+          - JOB="3.6_ASV" ASV=true
       - dist: trusty
         env:
           - JOB="3.6_DOC" DOC=true
@@ -128,6 +135,7 @@ script:
   - ci/script_single.sh
   - ci/script_multi.sh
   - ci/lint.sh
+  - ci/asv.sh
   - echo "checking imports"
   - source activate pandas && python ci/check_imports.py
   - echo "script done"

asv_bench/benchmarks/algorithms.py

@@ -1,3 +1,4 @@
+import warnings
 from importlib import import_module
 
 import numpy as np
@@ -83,7 +84,8 @@ def setup(self):
         self.all = self.uniques.repeat(10)
 
     def time_match_string(self):
-        pd.match(self.all, self.uniques)
+        with warnings.catch_warnings(record=True):
+            pd.match(self.all, self.uniques)
 
 
 class Hashing(object):

asv_bench/benchmarks/categoricals.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import pandas as pd
 import pandas.util.testing as tm
@@ -119,11 +121,15 @@ def setup(self):
 
         self.s_str = pd.Series(tm.makeCategoricalIndex(N, ncats)).astype(str)
         self.s_str_cat = self.s_str.astype('category')
-        self.s_str_cat_ordered = self.s_str.astype('category', ordered=True)
+        with warnings.catch_warnings(record=True):
+            self.s_str_cat_ordered = self.s_str.astype('category',
+                                                       ordered=True)
 
         self.s_int = pd.Series(np.random.randint(0, ncats, size=N))
         self.s_int_cat = self.s_int.astype('category')
-        self.s_int_cat_ordered = self.s_int.astype('category', ordered=True)
+        with warnings.catch_warnings(record=True):
+            self.s_int_cat_ordered = self.s_int.astype('category',
+                                                       ordered=True)
 
     def time_rank_string(self):
         self.s_str.rank()

asv_bench/benchmarks/frame_methods.py

@@ -1,4 +1,6 @@
 import string
+import warnings
+
 import numpy as np
 import pandas.util.testing as tm
 from pandas import (DataFrame, Series, MultiIndex, date_range, period_range,
@@ -15,7 +17,8 @@ def setup(self):
         self.df = DataFrame(np.random.randn(10000, 25))
         self.df['foo'] = 'bar'
         self.df['bar'] = 'baz'
-        self.df = self.df.consolidate()
+        with warnings.catch_warnings(record=True):
+            self.df = self.df.consolidate()
 
     def time_frame_get_numeric_data(self):
         self.df._get_numeric_data()
@@ -141,8 +144,8 @@ class Repr(object):
     def setup(self):
         nrows = 10000
         data = np.random.randn(nrows, 10)
-        idx = MultiIndex.from_arrays(np.tile(np.random.randn(3, nrows / 100),
-                                             100))
+        arrays = np.tile(np.random.randn(3, int(nrows / 100)), 100)
+        idx = MultiIndex.from_arrays(arrays)
         self.df3 = DataFrame(data, index=idx)
         self.df4 = DataFrame(data, index=np.random.randn(nrows))
         self.df_tall = DataFrame(np.random.randn(nrows, 10))

asv_bench/benchmarks/gil.py

@@ -1,9 +1,13 @@
 import numpy as np
 import pandas.util.testing as tm
-from pandas import (DataFrame, Series, rolling_median, rolling_mean,
-                    rolling_min, rolling_max, rolling_var, rolling_skew,
-                    rolling_kurt, rolling_std, read_csv, factorize, date_range)
+from pandas import DataFrame, Series, read_csv, factorize, date_range
 from pandas.core.algorithms import take_1d
+try:
+    from pandas import (rolling_median, rolling_mean, rolling_min, rolling_max,
+                        rolling_var, rolling_skew, rolling_kurt, rolling_std)
+    have_rolling_methods = True
+except ImportError:
+    have_rolling_methods = False
 try:
     from pandas._libs import algos
 except ImportError:
@@ -171,8 +175,7 @@ def run(period):
 class ParallelRolling(object):
 
     goal_time = 0.2
-    params = ['rolling_median', 'rolling_mean', 'rolling_min', 'rolling_max',
-              'rolling_var', 'rolling_skew', 'rolling_kurt', 'rolling_std']
+    params = ['median', 'mean', 'min', 'max', 'var', 'skew', 'kurt', 'std']
     param_names = ['method']
 
     def setup(self, method):
@@ -181,34 +184,28 @@ def setup(self, method):
         win = 100
         arr = np.random.rand(100000)
         if hasattr(DataFrame, 'rolling'):
-            rolling = {'rolling_median': 'median',
-                       'rolling_mean': 'mean',
-                       'rolling_min': 'min',
-                       'rolling_max': 'max',
-                       'rolling_var': 'var',
-                       'rolling_skew': 'skew',
-                       'rolling_kurt': 'kurt',
-                       'rolling_std': 'std'}
             df = DataFrame(arr).rolling(win)
 
             @test_parallel(num_threads=2)
             def parallel_rolling():
-                getattr(df, rolling[method])()
+                getattr(df, method)()
             self.parallel_rolling = parallel_rolling
-        else:
-            rolling = {'rolling_median': rolling_median,
-                       'rolling_mean': rolling_mean,
-                       'rolling_min': rolling_min,
-                       'rolling_max': rolling_max,
-                       'rolling_var': rolling_var,
-                       'rolling_skew': rolling_skew,
-                       'rolling_kurt': rolling_kurt,
-                       'rolling_std': rolling_std}
+        elif have_rolling_methods:
+            rolling = {'median': rolling_median,
+                       'mean': rolling_mean,
+                       'min': rolling_min,
+                       'max': rolling_max,
+                       'var': rolling_var,
+                       'skew': rolling_skew,
+                       'kurt': rolling_kurt,
+                       'std': rolling_std}
 
             @test_parallel(num_threads=2)
             def parallel_rolling():
                 rolling[method](arr, win)
             self.parallel_rolling = parallel_rolling
+        else:
+            raise NotImplementedError
 
     def time_rolling(self, method):
         self.parallel_rolling()

asv_bench/benchmarks/groupby.py

@@ -1,3 +1,4 @@
+import warnings
 from string import ascii_letters
 from itertools import product
 from functools import partial
@@ -159,6 +160,22 @@ def time_series_nth(self, df):
         df[1].groupby(df[0]).nth(0)
 
 
+class NthObject(object):
+
+    goal_time = 0.2
+
+    def setup_cache(self):
+        df = DataFrame(np.random.randint(1, 100, (10000,)), columns=['g'])
+        df['obj'] = ['a'] * 5000 + ['b'] * 5000
+        return df
+
+    def time_nth(self, df):
+        df.groupby('g').nth(5)
+
+    def time_nth_last(self, df):
+        df.groupby('g').last()
+
+
 class DateAttributes(object):
 
     goal_time = 0.2
@@ -340,7 +357,8 @@ def time_dt_size(self):
         self.df.groupby(['dates']).size()
 
     def time_dt_timegrouper_size(self):
-        self.df.groupby(TimeGrouper(key='dates', freq='M')).size()
+        with warnings.catch_warnings(record=True):
+            self.df.groupby(TimeGrouper(key='dates', freq='M')).size()
 
     def time_category_size(self):
         self.draws.groupby(self.cats).size()
@@ -467,7 +485,7 @@ class SumMultiLevel(object):
 
     def setup(self):
         N = 50
-        self.df = DataFrame({'A': range(N) * 2,
+        self.df = DataFrame({'A': list(range(N)) * 2,
                              'B': range(N * 2),
                              'C': 1}).set_index(['A', 'B'])
 

asv_bench/benchmarks/index_object.py

@@ -147,6 +147,11 @@ def setup(self, dtype):
         self.idx = getattr(tm, 'make{}Index'.format(dtype))(N)
         self.array_mask = (np.arange(N) % 3) == 0
         self.series_mask = Series(self.array_mask)
+        self.sorted = self.idx.sort_values()
+        half = N // 2
+        self.non_unique = self.idx[:half].append(self.idx[:half])
+        self.non_unique_sorted = self.sorted[:half].append(self.sorted[:half])
+        self.key = self.sorted[N // 4]
 
     def time_boolean_array(self, dtype):
         self.idx[self.array_mask]
@@ -163,6 +168,18 @@ def time_slice(self, dtype):
     def time_slice_step(self, dtype):
         self.idx[::2]
 
+    def time_get_loc(self, dtype):
+        self.idx.get_loc(self.key)
+
+    def time_get_loc_sorted(self, dtype):
+        self.sorted.get_loc(self.key)
+
+    def time_get_loc_non_unique(self, dtype):
+        self.non_unique.get_loc(self.key)
+
+    def time_get_loc_non_unique_sorted(self, dtype):
+        self.non_unique_sorted.get_loc(self.key)
+
 
 class Float64IndexMethod(object):
     # GH 13166

asv_bench/benchmarks/indexing.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import pandas.util.testing as tm
 from pandas import (Series, DataFrame, MultiIndex, Int64Index, Float64Index,
@@ -91,7 +93,8 @@ def time_getitem_pos_slice(self, index):
         self.s[:80000]
 
     def time_get_value(self, index):
-        self.s.get_value(self.lbl)
+        with warnings.catch_warnings(record=True):
+            self.s.get_value(self.lbl)
 
     def time_getitem_scalar(self, index):
         self.s[self.lbl]
@@ -112,7 +115,8 @@ def setup(self):
         self.bool_obj_indexer = self.bool_indexer.astype(object)
 
     def time_get_value(self):
-        self.df.get_value(self.idx_scalar, self.col_scalar)
+        with warnings.catch_warnings(record=True):
+            self.df.get_value(self.idx_scalar, self.col_scalar)
 
     def time_ix(self):
         self.df.ix[self.idx_scalar, self.col_scalar]
@@ -231,11 +235,13 @@ class PanelIndexing(object):
     goal_time = 0.2
 
     def setup(self):
-        self.p = Panel(np.random.randn(100, 100, 100))
-        self.inds = range(0, 100, 10)
+        with warnings.catch_warnings(record=True):
+            self.p = Panel(np.random.randn(100, 100, 100))
+            self.inds = range(0, 100, 10)
 
     def time_subset(self):
-        self.p.ix[(self.inds, self.inds, self.inds)]
+        with warnings.catch_warnings(record=True):
+            self.p.ix[(self.inds, self.inds, self.inds)]
 
 
 class MethodLookup(object):
@@ -295,7 +301,8 @@ def setup(self):
     def time_insert(self):
         np.random.seed(1234)
         for i in range(100):
-            self.df.insert(0, i, np.random.randn(self.N))
+            self.df.insert(0, i, np.random.randn(self.N),
+                           allow_duplicates=True)
 
     def time_assign_with_setitem(self):
         np.random.seed(1234)

asv_bench/benchmarks/io/hdf.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 from pandas import DataFrame, Panel, date_range, HDFStore, read_hdf
 import pandas.util.testing as tm
@@ -105,22 +107,25 @@ class HDFStorePanel(BaseIO):
 
     def setup(self):
         self.fname = '__test__.h5'
-        self.p = Panel(np.random.randn(20, 1000, 25),
-                       items=['Item%03d' % i for i in range(20)],
-                       major_axis=date_range('1/1/2000', periods=1000),
-                       minor_axis=['E%03d' % i for i in range(25)])
-        self.store = HDFStore(self.fname)
-        self.store.append('p1', self.p)
+        with warnings.catch_warnings(record=True):
+            self.p = Panel(np.random.randn(20, 1000, 25),
+                           items=['Item%03d' % i for i in range(20)],
+                           major_axis=date_range('1/1/2000', periods=1000),
+                           minor_axis=['E%03d' % i for i in range(25)])
+            self.store = HDFStore(self.fname)
+            self.store.append('p1', self.p)
 
     def teardown(self):
         self.store.close()
         self.remove(self.fname)
 
     def time_read_store_table_panel(self):
-        self.store.select('p1')
+        with warnings.catch_warnings(record=True):
+            self.store.select('p1')
 
     def time_write_store_table_panel(self):
-        self.store.append('p2', self.p)
+        with warnings.catch_warnings(record=True):
+            self.store.append('p2', self.p)
 
 
 class HDF(BaseIO):

asv_bench/benchmarks/join_merge.py

@@ -1,3 +1,4 @@
+import warnings
 import string
 
 import numpy as np
@@ -26,7 +27,8 @@ def setup(self):
         self.mdf1['obj2'] = 'bar'
         self.mdf1['int1'] = 5
         try:
-            self.mdf1.consolidate(inplace=True)
+            with warnings.catch_warnings(record=True):
+                self.mdf1.consolidate(inplace=True)
         except:
             pass
         self.mdf2 = self.mdf1.copy()
@@ -75,16 +77,23 @@ class ConcatPanels(object):
     param_names = ['axis', 'ignore_index']
 
     def setup(self, axis, ignore_index):
-        panel_c = Panel(np.zeros((10000, 200, 2), dtype=np.float32, order='C'))
-        self.panels_c = [panel_c] * 20
-        panel_f = Panel(np.zeros((10000, 200, 2), dtype=np.float32, order='F'))
-        self.panels_f = [panel_f] * 20
+        with warnings.catch_warnings(record=True):
+            panel_c = Panel(np.zeros((10000, 200, 2),
+                                     dtype=np.float32,
+                                     order='C'))
+            self.panels_c = [panel_c] * 20
+            panel_f = Panel(np.zeros((10000, 200, 2),
+                            dtype=np.float32,
+                            order='F'))
+            self.panels_f = [panel_f] * 20
 
     def time_c_ordered(self, axis, ignore_index):
-        concat(self.panels_c, axis=axis, ignore_index=ignore_index)
+        with warnings.catch_warnings(record=True):
+            concat(self.panels_c, axis=axis, ignore_index=ignore_index)
 
     def time_f_ordered(self, axis, ignore_index):
-        concat(self.panels_f, axis=axis, ignore_index=ignore_index)
+        with warnings.catch_warnings(record=True):
+            concat(self.panels_f, axis=axis, ignore_index=ignore_index)
 
 
 class ConcatDataFrames(object):