Merge branch 'master' into read_excel_doc

Author: JanLauGe

.travis.yml

@@ -51,7 +51,7 @@ matrix:
           - python-gtk2
     - dist: trusty
       env:
-        - JOB="3.5" TEST_ARGS="--skip-slow --skip-network" COVERAGE=true
+        - JOB="3.5_CONDA_BUILD_TEST" TEST_ARGS="--skip-slow --skip-network" CONDA_BUILD_TEST=true COVERAGE=true
     - dist: trusty
       env:
         - JOB="3.6" TEST_ARGS="--skip-slow --skip-network" PANDAS_TESTING_MODE="deprecate" CONDA_FORGE=true
@@ -62,7 +62,7 @@ matrix:
     # In allow_failures
     - dist: trusty
       env:
-        - JOB="3.6_BUILD_TEST" TEST_ARGS="--skip-slow" BUILD_TEST=true
+        - JOB="3.6_PIP_BUILD_TEST" TEST_ARGS="--skip-slow" PIP_BUILD_TEST=true
       addons:
         apt:
           packages:
@@ -81,7 +81,7 @@ matrix:
           - JOB="2.7_SLOW" SLOW=true
       - dist: trusty
         env:
-          - JOB="3.6_BUILD_TEST" TEST_ARGS="--skip-slow" BUILD_TEST=true
+          - JOB="3.6_PIP_BUILD_TEST" TEST_ARGS="--skip-slow" PIP_BUILD_TEST=true
         addons:
           apt:
             packages:

asv_bench/benchmarks/ctors.py

@@ -1,10 +1,36 @@
 import numpy as np
-from pandas import DataFrame, Series, Index, DatetimeIndex, Timestamp
+from pandas import Series, Index, DatetimeIndex, Timestamp
 
 from .pandas_vb_common import setup # noqa
 
 
-class Constructors(object):
+class SeriesConstructors(object):
+
+    goal_time = 0.2
+
+    param_names = ["data_fmt", "with_index"]
+    params = [[lambda x: x,
+               list,
+               lambda arr: list(arr.astype(str)),
+               lambda arr: dict(zip(range(len(arr)), arr)),
+               lambda arr: [(i, -i) for i in arr],
+               lambda arr: [[i, -i] for i in arr],
+               lambda arr: ([(i, -i) for i in arr][:-1] + [None]),
+               lambda arr: ([[i, -i] for i in arr][:-1] + [None])],
+              [False, True]]
+
+    def setup(self, data_fmt, with_index):
+        N = 10**4
+        np.random.seed(1234)
+        arr = np.random.randn(N)
+        self.data = data_fmt(arr)
+        self.index = np.arange(N) if with_index else None
+
+    def time_series_constructor(self, data_fmt, with_index):
+        Series(self.data, index=self.index)
+
+
+class SeriesDtypesConstructors(object):
 
     goal_time = 0.2
 
@@ -19,12 +45,6 @@ def setup(self):
         self.s = Series([Timestamp('20110101'), Timestamp('20120101'),
                          Timestamp('20130101')] * N * 10)
 
-    def time_frame_from_ndarray(self):
-        DataFrame(self.arr)
-
-    def time_series_from_ndarray(self):
-        Series(self.data, index=self.index)
-
     def time_index_from_array_string(self):
         Index(self.arr_str)
 

asv_bench/benchmarks/frame_ctor.py

@@ -81,3 +81,15 @@ def setup(self, nrows):
     def time_frame_from_records_generator(self, nrows):
         # issue-6700
         self.df = DataFrame.from_records(self.gen, nrows=nrows)
+
+
+class FromNDArray(object):
+
+    goal_time = 0.2
+
+    def setup(self):
+        N = 100000
+        self.data = np.random.randn(N)
+
+    def time_frame_from_ndarray(self):
+        self.df = DataFrame(self.data)

asv_bench/benchmarks/gil.py

@@ -180,19 +180,35 @@ def setup(self, method):
             raise NotImplementedError
         win = 100
         arr = np.random.rand(100000)
-        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
+        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
 
     def time_rolling(self, method):
         self.parallel_rolling()

asv_bench/benchmarks/inference.py

@@ -1,77 +1,80 @@
-from .pandas_vb_common import *
-import pandas as pd
+import numpy as np
+import pandas.util.testing as tm
+from pandas import DataFrame, Series, to_numeric
 
+from .pandas_vb_common import numeric_dtypes, lib, setup  # noqa
 
-class DtypeInfer(object):
-    goal_time = 0.2
 
+class NumericInferOps(object):
     # from GH 7332
+    goal_time = 0.2
+    params = numeric_dtypes
+    param_names = ['dtype']
+
+    def setup(self, dtype):
+        N = 5 * 10**5
+        self.df = DataFrame({'A': np.arange(N).astype(dtype),
+                             'B': np.arange(N).astype(dtype)})
+
+    def time_add(self, dtype):
+        self.df['A'] + self.df['B']
+
+    def time_subtract(self, dtype):
+        self.df['A'] - self.df['B']
 
-    def setup(self):
-        self.N = 500000
-        self.df_int64 = DataFrame(dict(A=np.arange(self.N, dtype='int64'),
-                                       B=np.arange(self.N, dtype='int64')))
-        self.df_int32 = DataFrame(dict(A=np.arange(self.N, dtype='int32'),
-                                       B=np.arange(self.N, dtype='int32')))
-        self.df_uint32 = DataFrame(dict(A=np.arange(self.N, dtype='uint32'),
-                                        B=np.arange(self.N, dtype='uint32')))
-        self.df_float64 = DataFrame(dict(A=np.arange(self.N, dtype='float64'),
-                                         B=np.arange(self.N, dtype='float64')))
-        self.df_float32 = DataFrame(dict(A=np.arange(self.N, dtype='float32'),
-                                         B=np.arange(self.N, dtype='float32')))
-        self.df_datetime64 = DataFrame(dict(A=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms'),
-                                            B=pd.to_datetime(np.arange(self.N, dtype='int64'), unit='ms')))
-        self.df_timedelta64 = DataFrame(dict(A=(self.df_datetime64['A'] - self.df_datetime64['B']),
-                                             B=self.df_datetime64['B']))
+    def time_multiply(self, dtype):
+        self.df['A'] * self.df['B']
 
-    def time_int64(self):
-        (self.df_int64['A'] + self.df_int64['B'])
+    def time_divide(self, dtype):
+        self.df['A'] / self.df['B']
 
-    def time_int32(self):
-        (self.df_int32['A'] + self.df_int32['B'])
+    def time_modulo(self, dtype):
+        self.df['A'] % self.df['B']
 
-    def time_uint32(self):
-        (self.df_uint32['A'] + self.df_uint32['B'])
 
-    def time_float64(self):
-        (self.df_float64['A'] + self.df_float64['B'])
+class DateInferOps(object):
+    # from GH 7332
+    goal_time = 0.2
+
+    def setup_cache(self):
+        N = 5 * 10**5
+        df = DataFrame({'datetime64': np.arange(N).astype('datetime64[ms]')})
+        df['timedelta'] = df['datetime64'] - df['datetime64']
+        return df
 
-    def time_float32(self):
-        (self.df_float32['A'] + self.df_float32['B'])
+    def time_subtract_datetimes(self, df):
+        df['datetime64'] - df['datetime64']
 
-    def time_datetime64(self):
-        (self.df_datetime64['A'] - self.df_datetime64['B'])
+    def time_timedelta_plus_datetime(self, df):
+        df['timedelta'] + df['datetime64']
 
-    def time_timedelta64_1(self):
-        (self.df_timedelta64['A'] + self.df_timedelta64['B'])
+    def time_add_timedeltas(self, df):
+        df['timedelta'] + df['timedelta']
 
-    def time_timedelta64_2(self):
-        (self.df_timedelta64['A'] + self.df_timedelta64['A'])
 
+class ToNumeric(object):
 
-class to_numeric(object):
     goal_time = 0.2
+    params = ['ignore', 'coerce']
+    param_names = ['errors']
 
-    def setup(self):
-        self.n = 10000
-        self.float = Series(np.random.randn(self.n * 100))
+    def setup(self, errors):
+        N = 10000
+        self.float = Series(np.random.randn(N))
         self.numstr = self.float.astype('str')
-        self.str = Series(tm.makeStringIndex(self.n))
+        self.str = Series(tm.makeStringIndex(N))
 
-    def time_from_float(self):
-        pd.to_numeric(self.float)
+    def time_from_float(self, errors):
+        to_numeric(self.float, errors=errors)
 
-    def time_from_numeric_str(self):
-        pd.to_numeric(self.numstr)
+    def time_from_numeric_str(self, errors):
+        to_numeric(self.numstr, errors=errors)
 
-    def time_from_str_ignore(self):
-        pd.to_numeric(self.str, errors='ignore')
+    def time_from_str(self, errors):
+        to_numeric(self.str, errors=errors)
 
-    def time_from_str_coerce(self):
-        pd.to_numeric(self.str, errors='coerce')
 
-
-class to_numeric_downcast(object):
+class ToNumericDowncast(object):
 
     param_names = ['dtype', 'downcast']
     params = [['string-float', 'string-int', 'string-nint', 'datetime64',
@@ -81,37 +84,30 @@ class to_numeric_downcast(object):
     N = 500000
     N2 = int(N / 2)
 
-    data_dict = {
-        'string-int': (['1'] * N2) + ([2] * N2),
-        'string-nint': (['-1'] * N2) + ([2] * N2),
-        'datetime64': np.repeat(np.array(['1970-01-01', '1970-01-02'],
-                                         dtype='datetime64[D]'), N),
-        'string-float': (['1.1'] * N2) + ([2] * N2),
-        'int-list': ([1] * N2) + ([2] * N2),
-        'int32': np.repeat(np.int32(1), N)
-        }
+    data_dict = {'string-int': ['1'] * N2 + [2] * N2,
+                 'string-nint': ['-1'] * N2 + [2] * N2,
+                 'datetime64': np.repeat(np.array(['1970-01-01', '1970-01-02'],
+                                                  dtype='datetime64[D]'), N),
+                 'string-float': ['1.1'] * N2 + [2] * N2,
+                 'int-list': [1] * N2 + [2] * N2,
+                 'int32': np.repeat(np.int32(1), N)}
 
     def setup(self, dtype, downcast):
         self.data = self.data_dict[dtype]
 
     def time_downcast(self, dtype, downcast):
-        pd.to_numeric(self.data, downcast=downcast)
+        to_numeric(self.data, downcast=downcast)
 
 
 class MaybeConvertNumeric(object):
 
-    def setup(self):
-        n = 1000000
-        arr = np.repeat([2**63], n)
-        arr = arr + np.arange(n).astype('uint64')
-        arr = np.array([arr[i] if i%2 == 0 else
-                        str(arr[i]) for i in range(n)],
-                       dtype=object)
-
-        arr[-1] = -1
-        self.data = arr
-        self.na_values = set()
-
-    def time_convert(self):
-        lib.maybe_convert_numeric(self.data, self.na_values,
-                                  coerce_numeric=False)
+    def setup_cache(self):
+        N = 10**6
+        arr = np.repeat([2**63], N) + np.arange(N).astype('uint64')
+        data = arr.astype(object)
+        data[1::2] = arr[1::2].astype(str)
+        data[-1] = -1
+        return data
+
+    def time_convert(self, data):
+        lib.maybe_convert_numeric(data, set(), coerce_numeric=False)