Merge remote-tracking branch 'upstream/master' into pd.Series.map_performance

Author: Rohith295

.travis.yml

@@ -58,12 +58,6 @@ matrix:
       services:
         - mysql
         - postgresql
-
-    - env:
-        - JOB="3.6, slow" ENV_FILE="ci/deps/travis-36-slow.yaml" PATTERN="slow" SQL="1"
-      services:
-        - mysql
-        - postgresql
   allow_failures:
     - arch: arm64
       env:

LICENSES/XARRAY_LICENSE

@@ -1,3 +1,7 @@
+Copyright 2014-2019, xarray Developers
+
+--------------------------------------------------------------------------------
+
 Apache License
 Version 2.0, January 2004
 http://www.apache.org/licenses/

asv_bench/asv.conf.json

@@ -53,6 +53,7 @@
         "xlwt": [],
         "odfpy": [],
         "pytest": [],
+        "jinja2": [],
         // If using Windows with python 2.7 and want to build using the
         // mingw toolchain (rather than MSVC), uncomment the following line.
         // "libpython": [],

asv_bench/benchmarks/io/style.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+from pandas import DataFrame
+
+
+class RenderApply:
+
+    params = [[12, 24, 36], [12, 120]]
+    param_names = ["cols", "rows"]
+
+    def setup(self, cols, rows):
+        self.df = DataFrame(
+            np.random.randn(rows, cols),
+            columns=[f"float_{i+1}" for i in range(cols)],
+            index=[f"row_{i+1}" for i in range(rows)],
+        )
+        self._style_apply()
+
+    def time_render(self, cols, rows):
+        self.st.render()
+
+    def peakmem_apply(self, cols, rows):
+        self._style_apply()
+
+    def peakmem_render(self, cols, rows):
+        self.st.render()
+
+    def _style_apply(self):
+        def _apply_func(s):
+            return [
+                "background-color: lightcyan" if s.name == "row_1" else "" for v in s
+            ]
+
+        self.st = self.df.style.apply(_apply_func, axis=1)

asv_bench/benchmarks/rolling.py

@@ -91,11 +91,18 @@ class EWMMethods:
     def setup(self, constructor, window, dtype, method):
         N = 10 ** 5
         arr = (100 * np.random.random(N)).astype(dtype)
+        times = pd.date_range("1900", periods=N, freq="23s")
         self.ewm = getattr(pd, constructor)(arr).ewm(halflife=window)
+        self.ewm_times = getattr(pd, constructor)(arr).ewm(
+            halflife="1 Day", times=times
+        )
 
     def time_ewm(self, constructor, window, dtype, method):
         getattr(self.ewm, method)()
 
+    def time_ewm_times(self, constructor, window, dtype, method):
+        self.ewm.mean()
+
 
 class VariableWindowMethods(Methods):
     params = (

asv_bench/benchmarks/tslibs/fields.py

@@ -0,0 +1,74 @@
+import numpy as np
+
+from pandas._libs.tslibs.fields import (
+    get_date_field,
+    get_start_end_field,
+    get_timedelta_field,
+)
+
+from .tslib import _sizes
+
+
+class TimeGetTimedeltaField:
+    params = [
+        _sizes,
+        ["days", "h", "s", "seconds", "ms", "microseconds", "us", "ns", "nanoseconds"],
+    ]
+    param_names = ["size", "field"]
+
+    def setup(self, size, field):
+        arr = np.random.randint(0, 10, size=size, dtype="i8")
+        self.i8data = arr
+
+    def time_get_timedelta_field(self, size, field):
+        get_timedelta_field(self.i8data, field)
+
+
+class TimeGetDateField:
+    params = [
+        _sizes,
+        [
+            "Y",
+            "M",
+            "D",
+            "h",
+            "m",
+            "s",
+            "us",
+            "ns",
+            "doy",
+            "dow",
+            "woy",
+            "q",
+            "dim",
+            "is_leap_year",
+        ],
+    ]
+    param_names = ["size", "field"]
+
+    def setup(self, size, field):
+        arr = np.random.randint(0, 10, size=size, dtype="i8")
+        self.i8data = arr
+
+    def time_get_date_field(self, size, field):
+        get_date_field(self.i8data, field)
+
+
+class TimeGetStartEndField:
+    params = [
+        _sizes,
+        ["start", "end"],
+        ["month", "quarter", "year"],
+        ["B", None, "QS"],
+        [12, 3, 5],
+    ]
+    param_names = ["size", "side", "period", "freqstr", "month_kw"]
+
+    def setup(self, size, side, period, freqstr, month_kw):
+        arr = np.random.randint(0, 10, size=size, dtype="i8")
+        self.i8data = arr
+
+        self.attrname = f"is_{period}_{side}"
+
+    def time_get_start_end_field(self, size, side, period, freqstr, month_kw):
+        get_start_end_field(self.i8data, self.attrname, freqstr, month_kw=month_kw)

asv_bench/benchmarks/tslibs/normalize.py

@@ -0,0 +1,32 @@
+try:
+    from pandas._libs.tslibs import normalize_i8_timestamps, is_date_array_normalized
+except ImportError:
+    from pandas._libs.tslibs.conversion import (
+        normalize_i8_timestamps,
+        is_date_array_normalized,
+    )
+
+import pandas as pd
+
+from .tslib import _sizes, _tzs
+
+
+class Normalize:
+    params = [
+        _sizes,
+        _tzs,
+    ]
+    param_names = ["size", "tz"]
+
+    def setup(self, size, tz):
+        # use an array that will have is_date_array_normalized give True,
+        #  so we do not short-circuit early.
+        dti = pd.date_range("2016-01-01", periods=10, tz=tz).repeat(size // 10)
+        self.i8data = dti.asi8
+
+    def time_normalize_i8_timestamps(self, size, tz):
+        normalize_i8_timestamps(self.i8data, tz)
+
+    def time_is_date_array_normalized(self, size, tz):
+        # TODO: cases with different levels of short-circuiting
+        is_date_array_normalized(self.i8data, tz)

asv_bench/benchmarks/tslibs/period.py

@@ -2,10 +2,20 @@
 Period benchmarks that rely only on tslibs.  See benchmarks.period for
 Period benchmarks that rely on other parts fo pandas.
 """
-from pandas import Period
+
+import numpy as np
+
+from pandas._libs.tslibs.period import Period, periodarr_to_dt64arr
 
 from pandas.tseries.frequencies import to_offset
 
+from .tslib import _sizes, _tzs
+
+try:
+    from pandas._libs.tslibs.vectorized import dt64arr_to_periodarr
+except ImportError:
+    from pandas._libs.tslibs.period import dt64arr_to_periodarr
+
 
 class PeriodProperties:
 
@@ -68,3 +78,53 @@ def setup(self, freq, is_offset):
 
     def time_period_constructor(self, freq, is_offset):
         Period("2012-06-01", freq=freq)
+
+
+_freq_ints = [
+    1000,
+    1011,  # Annual - November End
+    2000,
+    2011,  # Quarterly - November End
+    3000,
+    4000,
+    4006,  # Weekly - Saturday End
+    5000,
+    6000,
+    7000,
+    8000,
+    9000,
+    10000,
+    11000,
+    12000,
+]
+
+
+class TimePeriodArrToDT64Arr:
+    params = [
+        _sizes,
+        _freq_ints,
+    ]
+    param_names = ["size", "freq"]
+
+    def setup(self, size, freq):
+        arr = np.arange(10, dtype="i8").repeat(size // 10)
+        self.i8values = arr
+
+    def time_periodarray_to_dt64arr(self, size, freq):
+        periodarr_to_dt64arr(self.i8values, freq)
+
+
+class TimeDT64ArrToPeriodArr:
+    params = [
+        _sizes,
+        _freq_ints,
+        _tzs,
+    ]
+    param_names = ["size", "freq", "tz"]
+
+    def setup(self, size, freq, tz):
+        arr = np.arange(10, dtype="i8").repeat(size // 10)
+        self.i8values = arr
+
+    def time_dt64arr_to_periodarr(self, size, freq, tz):
+        dt64arr_to_periodarr(self.i8values, freq, tz)

asv_bench/benchmarks/tslibs/resolution.py

@@ -0,0 +1,53 @@
+"""
+ipython analogue:
+
+tr = TimeResolution()
+mi = pd.MultiIndex.from_product(tr.params[:-1] + ([str(x) for x in tr.params[-1]],))
+df = pd.DataFrame(np.nan, index=mi, columns=["mean", "stdev"])
+
+for unit in tr.params[0]:
+    for size in tr.params[1]:
+        for tz in tr.params[2]:
+            tr.setup(unit, size, tz)
+            key = (unit, size, str(tz))
+            print(key)
+
+            val = %timeit -o tr.time_get_resolution(unit, size, tz)
+
+            df.loc[key] = (val.average, val.stdev)
+
+"""
+from datetime import timedelta, timezone
+
+from dateutil.tz import gettz, tzlocal
+import numpy as np
+import pytz
+
+try:
+    from pandas._libs.tslibs import get_resolution
+except ImportError:
+    from pandas._libs.tslibs.resolution import get_resolution
+
+
+class TimeResolution:
+    params = (
+        ["D", "h", "m", "s", "us", "ns"],
+        [1, 100, 10 ** 4, 10 ** 6],
+        [
+            None,
+            timezone.utc,
+            timezone(timedelta(minutes=60)),
+            pytz.timezone("US/Pacific"),
+            gettz("Asia/Tokyo"),
+            tzlocal(),
+        ],
+    )
+    param_names = ["unit", "size", "tz"]
+
+    def setup(self, unit, size, tz):
+        arr = np.random.randint(0, 10, size=size, dtype="i8")
+        arr = arr.view(f"M8[{unit}]").astype("M8[ns]").view("i8")
+        self.i8data = arr
+
+    def time_get_resolution(self, unit, size, tz):
+        get_resolution(self.i8data, tz)

asv_bench/benchmarks/tslibs/timestamp.py

@@ -1,17 +1,29 @@
-import datetime
+from datetime import datetime, timedelta, timezone
 
-import dateutil
+from dateutil.tz import gettz, tzlocal, tzutc
 import numpy as np
 import pytz
 
 from pandas import Timestamp
 
+# One case for each type of tzinfo object that has its own code path
+#  in tzconversion code.
+_tzs = [
+    None,
+    pytz.timezone("Europe/Amsterdam"),
+    gettz("US/Central"),
+    pytz.UTC,
+    tzutc(),
+    timezone(timedelta(minutes=60)),
+    tzlocal(),
+]
+
 
 class TimestampConstruction:
     def setup(self):
         self.npdatetime64 = np.datetime64("2020-01-01 00:00:00")
-        self.dttime_unaware = datetime.datetime(2020, 1, 1, 0, 0, 0)
-        self.dttime_aware = datetime.datetime(2020, 1, 1, 0, 0, 0, 0, pytz.UTC)
+        self.dttime_unaware = datetime(2020, 1, 1, 0, 0, 0)
+        self.dttime_aware = datetime(2020, 1, 1, 0, 0, 0, 0, pytz.UTC)
         self.ts = Timestamp("2020-01-01 00:00:00")
 
     def time_parse_iso8601_no_tz(self):
@@ -49,7 +61,6 @@ def time_from_pd_timestamp(self):
 
 
 class TimestampProperties:
-    _tzs = [None, pytz.timezone("Europe/Amsterdam"), pytz.UTC, dateutil.tz.tzutc()]
     _freqs = [None, "B"]
     params = [_tzs, _freqs]
     param_names = ["tz", "freq"]
@@ -63,9 +74,6 @@ def time_tz(self, tz, freq):
     def time_dayofweek(self, tz, freq):
         self.ts.dayofweek
 
-    def time_weekday_name(self, tz, freq):
-        self.ts.day_name
-
     def time_dayofyear(self, tz, freq):
         self.ts.dayofyear
 
@@ -108,9 +116,12 @@ def time_microsecond(self, tz, freq):
     def time_month_name(self, tz, freq):
         self.ts.month_name()
 
+    def time_weekday_name(self, tz, freq):
+        self.ts.day_name()
+
 
 class TimestampOps:
-    params = [None, "US/Eastern", pytz.UTC, dateutil.tz.tzutc()]
+    params = _tzs
     param_names = ["tz"]
 
     def setup(self, tz):
@@ -148,7 +159,7 @@ def time_ceil(self, tz):
 
 class TimestampAcrossDst:
     def setup(self):
-        dt = datetime.datetime(2016, 3, 27, 1)
+        dt = datetime(2016, 3, 27, 1)
         self.tzinfo = pytz.timezone("CET").localize(dt, is_dst=False).tzinfo
         self.ts2 = Timestamp(dt)