ENH: gb.is_monotonic_increasing pandas-dev#17015 rebase to master

Author: No-Stream

.gitignore

@@ -106,3 +106,4 @@ doc/build/html/index.html
 doc/tmp.sv
 doc/source/styled.xlsx
 doc/source/templates/
+env/

asv_bench/benchmarks/algorithms.py

@@ -11,6 +11,8 @@
     except:
         pass
 
+from .pandas_vb_common import setup # noqa
+
 
 class Factorize(object):
 
@@ -21,7 +23,6 @@ class Factorize(object):
 
     def setup(self, sort):
         N = 10**5
-        np.random.seed(1234)
         self.int_idx = pd.Int64Index(np.arange(N).repeat(5))
         self.float_idx = pd.Float64Index(np.random.randn(N).repeat(5))
         self.string_idx = tm.makeStringIndex(N)
@@ -45,7 +46,6 @@ class Duplicated(object):
 
     def setup(self, keep):
         N = 10**5
-        np.random.seed(1234)
         self.int_idx = pd.Int64Index(np.arange(N).repeat(5))
         self.float_idx = pd.Float64Index(np.random.randn(N).repeat(5))
         self.string_idx = tm.makeStringIndex(N)
@@ -79,7 +79,6 @@ class Match(object):
     goal_time = 0.2
 
     def setup(self):
-        np.random.seed(1234)
         self.uniques = tm.makeStringIndex(1000).values
         self.all = self.uniques.repeat(10)
 
@@ -92,7 +91,6 @@ class Hashing(object):
     goal_time = 0.2
 
     def setup_cache(self):
-        np.random.seed(1234)
         N = 10**5
 
         df = pd.DataFrame(

asv_bench/benchmarks/attrs_caching.py

@@ -1,18 +1,18 @@
 import numpy as np
 from pandas import DataFrame
-
 try:
     from pandas.util import cache_readonly
 except ImportError:
     from pandas.util.decorators import cache_readonly
 
+from .pandas_vb_common import setup  # noqa
+
 
 class DataFrameAttributes(object):
 
     goal_time = 0.2
 
     def setup(self):
-        np.random.seed(1234)
         self.df = DataFrame(np.random.randn(10, 6))
         self.cur_index = self.df.index
 

asv_bench/benchmarks/binary_ops.py

@@ -6,6 +6,8 @@
 except ImportError:
     import pandas.computation.expressions as expr
 
+from .pandas_vb_common import setup # noqa
+
 
 class Ops(object):
 
@@ -15,7 +17,6 @@ class Ops(object):
     param_names = ['use_numexpr', 'threads']
 
     def setup(self, use_numexpr, threads):
-        np.random.seed(1234)
         self.df = DataFrame(np.random.randn(20000, 100))
         self.df2 = DataFrame(np.random.randn(20000, 100))
 
@@ -47,7 +48,6 @@ class Ops2(object):
 
     def setup(self):
         N = 10**3
-        np.random.seed(1234)
         self.df = DataFrame(np.random.randn(N, N))
         self.df2 = DataFrame(np.random.randn(N, N))
 
@@ -89,14 +89,12 @@ class Timeseries(object):
     param_names = ['tz']
 
     def setup(self, tz):
-        self.N = 10**6
-        self.halfway = ((self.N // 2) - 1)
-        self.s = Series(date_range('20010101', periods=self.N, freq='T',
-                                   tz=tz))
-        self.ts = self.s[self.halfway]
+        N = 10**6
+        halfway = (N // 2) - 1
+        self.s = Series(date_range('20010101', periods=N, freq='T', tz=tz))
+        self.ts = self.s[halfway]
 
-        self.s2 = Series(date_range('20010101', periods=self.N, freq='s',
-                                    tz=tz))
+        self.s2 = Series(date_range('20010101', periods=N, freq='s', tz=tz))
 
     def time_series_timestamp_compare(self, tz):
         self.s <= self.ts
@@ -131,7 +129,6 @@ class AddOverflowArray(object):
     goal_time = 0.2
 
     def setup(self):
-        np.random.seed(1234)
         N = 10**6
         self.arr = np.arange(N)
         self.arr_rev = np.arange(-N, 0)

asv_bench/benchmarks/categoricals.py

@@ -9,6 +9,8 @@
     except ImportError:
         pass
 
+from .pandas_vb_common import setup # noqa
+
 
 class Concat(object):
 
@@ -76,7 +78,6 @@ class ValueCounts(object):
 
     def setup(self, dropna):
         n = 5 * 10**5
-        np.random.seed(2718281)
         arr = ['s%04d' % i for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype('category')
 
@@ -101,7 +102,6 @@ class SetCategories(object):
 
     def setup(self):
         n = 5 * 10**5
-        np.random.seed(2718281)
         arr = ['s%04d' % i for i in np.random.randint(0, n // 10, size=n)]
         self.ts = pd.Series(arr).astype('category')
 
@@ -116,7 +116,6 @@ class Rank(object):
     def setup(self):
         N = 10**5
         ncats = 100
-        np.random.seed(1234)
 
         self.s_str = pd.Series(tm.makeCategoricalIndex(N, ncats)).astype(str)
         self.s_str_cat = self.s_str.astype('category')

asv_bench/benchmarks/ctors.py

@@ -1,14 +1,15 @@
 import numpy as np
 from pandas import DataFrame, Series, Index, DatetimeIndex, Timestamp
 
+from .pandas_vb_common import setup # noqa
+
 
 class Constructors(object):
 
     goal_time = 0.2
 
     def setup(self):
         N = 10**2
-        np.random.seed(1234)
         self.arr = np.random.randn(N, N)
         self.arr_str = np.array(['foo', 'bar', 'baz'], dtype=object)
 

asv_bench/benchmarks/eval.py

@@ -5,6 +5,8 @@
 except ImportError:
     import pandas.computation.expressions as expr
 
+from .pandas_vb_common import setup # noqa
+
 
 class Eval(object):
 
@@ -14,7 +16,6 @@ class Eval(object):
     param_names = ['engine', 'threads']
 
     def setup(self, engine, threads):
-        np.random.seed(1234)
         self.df = pd.DataFrame(np.random.randn(20000, 100))
         self.df2 = pd.DataFrame(np.random.randn(20000, 100))
         self.df3 = pd.DataFrame(np.random.randn(20000, 100))
@@ -45,17 +46,16 @@ class Query(object):
     goal_time = 0.2
 
     def setup(self):
-        np.random.seed(1234)
-        self.N = 10**6
-        self.halfway = (self.N // 2) - 1
-        self.index = pd.date_range('20010101', periods=self.N, freq='T')
-        self.s = pd.Series(self.index)
-        self.ts = self.s.iloc[self.halfway]
-        self.df = pd.DataFrame({'a': np.random.randn(self.N), 'dates': self.s},
-                               index=self.index)
-        self.data = np.random.randn(self.N)
-        self.min_val = self.data.min()
-        self.max_val = self.data.max()
+        N = 10**6
+        halfway = (N // 2) - 1
+        index = pd.date_range('20010101', periods=N, freq='T')
+        s = pd.Series(index)
+        self.ts = s.iloc[halfway]
+        self.df = pd.DataFrame({'a': np.random.randn(N), 'dates': s},
+                               index=index)
+        data = np.random.randn(N)
+        self.min_val = data.min()
+        self.max_val = data.max()
 
     def time_query_datetime_index(self):
         self.df.query('index < @self.ts')

asv_bench/benchmarks/frame_ctor.py

@@ -2,125 +2,82 @@
 import pandas.util.testing as tm
 from pandas import DataFrame, Series, MultiIndex, Timestamp, date_range
 try:
-    from pandas.tseries import offsets
-except:
-    from pandas.core.datetools import *
+    from pandas.tseries.offsets import Nano, Hour
+except ImportError:
+    # For compatability with older versions
+    from pandas.core.datetools import * # noqa
 
+from .pandas_vb_common import setup # noqa
 
-# ----------------------------------------------------------------------
-# Creation from nested dict
 
 class FromDicts(object):
 
     goal_time = 0.2
 
     def setup(self):
-        np.random.seed(1234)
         N, K = 5000, 50
-        self.index = tm.makeStringIndex(N)
-        self.columns = tm.makeStringIndex(K)
-        self.frame = DataFrame(np.random.randn(N, K),
-                               index=self.index,
-                               columns=self.columns)
-        self.data = self.frame.to_dict()
+        index = tm.makeStringIndex(N)
+        columns = tm.makeStringIndex(K)
+        frame = DataFrame(np.random.randn(N, K), index=index, columns=columns)
+        self.data = frame.to_dict()
         self.some_dict = list(self.data.values())[0]
-        self.dict_list = self.frame.to_dict(orient='records')
+        self.dict_list = frame.to_dict(orient='records')
         self.data2 = {i: {j: float(j) for j in range(100)}
                       for i in range(2000)}
 
-    def time_frame_ctor_list_of_dict(self):
+    def time_list_of_dict(self):
         DataFrame(self.dict_list)
 
-    def time_frame_ctor_nested_dict(self):
+    def time_nested_dict(self):
         DataFrame(self.data)
 
-    def time_series_ctor_from_dict(self):
+    def time_dict(self):
         Series(self.some_dict)
 
-    def time_frame_ctor_nested_dict_int64(self):
+    def time_nested_dict_int64(self):
         # nested dict, integer indexes, regression described in #621
         DataFrame(self.data2)
 
 
-# from a mi-series
-
 class FromSeries(object):
+
     goal_time = 0.2
 
     def setup(self):
-        self.mi = MultiIndex.from_product([range(100), range(100)])
-        self.s = Series(np.random.randn(10000), index=self.mi)
+        mi = MultiIndex.from_product([range(100), range(100)])
+        self.s = Series(np.random.randn(10000), index=mi)
 
-    def time_frame_from_mi_series(self):
+    def time_mi_series(self):
         DataFrame(self.s)
 
-# ----------------------------------------------------------------------
-# From dict with DatetimeIndex with all offsets
-
-# dynamically generate benchmarks for every offset
-#
-# get_period_count & get_index_for_offset are there because blindly taking each
-# offset times 1000 can easily go out of Timestamp bounds and raise errors.
-
-
-def get_period_count(start_date, off):
-    ten_offsets_in_days = ((start_date + (off * 10)) - start_date).days
-    if (ten_offsets_in_days == 0):
-        return 1000
-    else:
-        periods = 9 * (Timestamp.max - start_date).days // ten_offsets_in_days
-        return min(periods, 1000)
-
 
-def get_index_for_offset(off):
-    start_date = Timestamp('1/1/1900')
-    return date_range(start_date,
-                      periods=get_period_count(start_date, off),
-                      freq=off)
+class FromDictwithTimestamp(object):
 
+    goal_time = 0.2
+    params = [Nano(1), Hour(1)]
+    param_names = ['offset']
 
-all_offsets = offsets.__all__
-# extra cases
-for off in ['FY5253', 'FY5253Quarter']:
-    all_offsets.pop(all_offsets.index(off))
-    all_offsets.extend([off + '_1', off + '_2'])
+    def setup(self, offset):
+        N = 10**3
+        np.random.seed(1234)
+        idx = date_range(Timestamp('1/1/1900'), freq=offset, periods=N)
+        df = DataFrame(np.random.randn(N, 10), index=idx)
+        self.d = df.to_dict()
 
+    def time_dict_with_timestamp_offsets(self, offset):
+        DataFrame(self.d)
 
-class FromDictwithTimestampOffsets(object):
 
-    params = [all_offsets, [1, 2]]
-    param_names = ['offset', 'n_steps']
+class FromRecords(object):
 
-    offset_kwargs = {'WeekOfMonth': {'weekday': 1, 'week': 1},
-                     'LastWeekOfMonth': {'weekday': 1, 'week': 1},
-                     'FY5253': {'startingMonth': 1, 'weekday': 1},
-                     'FY5253Quarter': {'qtr_with_extra_week': 1,
-                                       'startingMonth': 1,
-                                       'weekday': 1}}
+    goal_time = 0.2
+    params = [None, 1000]
+    param_names = ['nrows']
 
-    offset_extra_cases = {'FY5253': {'variation': ['nearest', 'last']},
-                          'FY5253Quarter': {'variation': ['nearest', 'last']}}
+    def setup(self, nrows):
+        N = 100000
+        self.gen = ((x, (x * 20), (x * 100)) for x in range(N))
 
-    def setup(self, offset, n_steps):
-        np.random.seed(1234)
-        extra = False
-        if offset.endswith("_", None, -1):
-            extra = int(offset[-1])
-            offset = offset[:-2]
-
-        kwargs = {}
-        if offset in self.offset_kwargs:
-            kwargs = self.offset_kwargs[offset]
-
-        if extra:
-            extras = self.offset_extra_cases[offset]
-            for extra_arg in extras:
-                kwargs[extra_arg] = extras[extra_arg][extra - 1]
-
-        offset = getattr(offsets, offset)
-        self.idx = get_index_for_offset(offset(n_steps, **kwargs))
-        self.df = DataFrame(np.random.randn(len(self.idx), 10), index=self.idx)
-        self.d = self.df.to_dict()
-
-    def time_frame_ctor(self, offset, n_steps):
-        DataFrame(self.d)
+    def time_frame_from_records_generator(self, nrows):
+        # issue-6700
+        self.df = DataFrame.from_records(self.gen, nrows=nrows)