CI: Run ASV on Travis for failed benchmarks

create asv.sh

add to travis

Changed file permission

Add else statement and asv machine config

move to separate travis build

CI: Run ASV on Travis for failed benchmarks

create asv.sh

add to travis

move to separate travis build

Change build order and change to asv dev

Put asv before doc

Fix some failing benchmarks

Grep for failed benchmarks

Add travis wait

Don't grep output yet

Remove travis_wait for now

fix some benchmarks

Now grep output

add travis wait 40 to ci/asv.sh

Add tee

Remove wait

Start catching warnings

catch more warnings

Fix ci strategy

Remove rolling_* from gil.py

catch more warnings

Author: mroeschke

.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,8 +1,6 @@
 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._libs import algos
@@ -171,44 +169,20 @@ 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):
         if not have_real_test_parallel:
             raise NotImplementedError
         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])()
-            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}
-
-            @test_parallel(num_threads=2)
-            def parallel_rolling():
-                rolling[method](arr, win)
-            self.parallel_rolling = parallel_rolling
+        df = DataFrame(arr).rolling(win)
+
+        @test_parallel(num_threads=2)
+        def parallel_rolling():
+            getattr(df, method)()
+        self.parallel_rolling = parallel_rolling
 
     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
@@ -340,7 +341,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 +469,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/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):

asv_bench/benchmarks/offset.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import warnings
 from datetime import datetime
 
 import numpy as np
@@ -76,7 +77,8 @@ def setup(self, offset):
         self.data = pd.Series(rng)
 
     def time_add_offset(self, offset):
-        self.data + offset
+        with warnings.catch_warnings(record=True):
+            self.data + offset
 
 
 class OffsetDatetimeIndexArithmetic(object):
@@ -90,7 +92,8 @@ def setup(self, offset):
         self.data = pd.date_range(start='1/1/2000', periods=N, freq='T')
 
     def time_add_offset(self, offset):
-        self.data + offset
+        with warnings.catch_warnings(record=True):
+            self.data + offset
 
 
 class OffestDatetimeArithmetic(object):