STY: isort tests/scalar, tests/tslibs, import libwindow instead of _window

pandas/core/window.py

@@ -7,41 +7,29 @@
 """
 from __future__ import division
 
-import warnings
-import numpy as np
 from collections import defaultdict
 from datetime import timedelta
+from textwrap import dedent
+import warnings
+
+import numpy as np
+
+import pandas._libs.window as libwindow
+import pandas.compat as compat
+from pandas.compat.numpy import function as nv
+from pandas.util._decorators import Appender, Substitution, cache_readonly
 
-from pandas.core.dtypes.generic import (
-    ABCSeries,
-    ABCDataFrame,
-    ABCDatetimeIndex,
-    ABCTimedeltaIndex,
-    ABCPeriodIndex,
-    ABCDateOffset)
 from pandas.core.dtypes.common import (
-    is_integer,
-    is_bool,
-    is_float_dtype,
-    is_integer_dtype,
-    needs_i8_conversion,
-    is_timedelta64_dtype,
-    is_list_like,
-    ensure_float64,
-    is_scalar)
+    ensure_float64, is_bool, is_float_dtype, is_integer, is_integer_dtype,
+    is_list_like, is_scalar, is_timedelta64_dtype, needs_i8_conversion)
+from pandas.core.dtypes.generic import (
+    ABCDataFrame, ABCDateOffset, ABCDatetimeIndex, ABCPeriodIndex, ABCSeries,
+    ABCTimedeltaIndex)
 
 from pandas.core.base import PandasObject, SelectionMixin
-from pandas.core.groupby.base import GroupByMixin
 import pandas.core.common as com
-import pandas._libs.window as _window
-
-from pandas import compat
-from pandas.compat.numpy import function as nv
-from pandas.util._decorators import (Substitution, Appender,
-                                     cache_readonly)
 from pandas.core.generic import _shared_docs
-from textwrap import dedent
-
+from pandas.core.groupby.base import GroupByMixin
 
 _shared_docs = dict(**_shared_docs)
 _doc_template = """
@@ -688,10 +676,10 @@ def _apply_window(self, mean=True, **kwargs):
 
             def f(arg, *args, **kwargs):
                 minp = _use_window(self.min_periods, len(window))
-                return _window.roll_window(np.concatenate((arg,
-                                                           additional_nans))
-                                           if center else arg, window, minp,
-                                           avg=mean)
+                return libwindow.roll_window(np.concatenate((arg,
+                                                             additional_nans))
+                                             if center else arg, window, minp,
+                                             avg=mean)
 
             result = np.apply_along_axis(f, self.axis, values)
 
@@ -848,10 +836,10 @@ def _apply(self, func, name=None, window=None, center=None,
 
             # if we have a string function name, wrap it
             if isinstance(func, compat.string_types):
-                cfunc = getattr(_window, func, None)
+                cfunc = getattr(libwindow, func, None)
                 if cfunc is None:
                     raise ValueError("we do not support this function "
-                                     "in _window.{0}".format(func))
+                                     "in libwindow.{func}".format(func=func))
 
                 def func(arg, window, min_periods=None, closed=None):
                     minp = check_minp(min_periods, window)
@@ -995,7 +983,7 @@ def f(arg, window, min_periods, closed):
             minp = _use_window(min_periods, window)
             if not raw:
                 arg = Series(arg, index=self.obj.index)
-            return _window.roll_generic(
+            return libwindow.roll_generic(
                 arg, window, minp, indexi,
                 closed, offset, func, raw, args, kwargs)
 
@@ -1160,8 +1148,8 @@ def std(self, ddof=1, *args, **kwargs):
 
         def f(arg, *args, **kwargs):
             minp = _require_min_periods(1)(self.min_periods, window)
-            return _zsqrt(_window.roll_var(arg, window, minp, indexi,
-                                           self.closed, ddof))
+            return _zsqrt(libwindow.roll_var(arg, window, minp, indexi,
+                                             self.closed, ddof))
 
         return self._apply(f, 'std', check_minp=_require_min_periods(1),
                            ddof=ddof, **kwargs)
@@ -1331,15 +1319,15 @@ def quantile(self, quantile, interpolation='linear', **kwargs):
         def f(arg, *args, **kwargs):
             minp = _use_window(self.min_periods, window)
             if quantile == 1.0:
-                return _window.roll_max(arg, window, minp, indexi,
-                                        self.closed)
+                return libwindow.roll_max(arg, window, minp, indexi,
+                                          self.closed)
             elif quantile == 0.0:
-                return _window.roll_min(arg, window, minp, indexi,
-                                        self.closed)
+                return libwindow.roll_min(arg, window, minp, indexi,
+                                          self.closed)
             else:
-                return _window.roll_quantile(arg, window, minp, indexi,
-                                             self.closed, quantile,
-                                             interpolation)
+                return libwindow.roll_quantile(arg, window, minp, indexi,
+                                               self.closed, quantile,
+                                               interpolation)
 
         return self._apply(f, 'quantile', quantile=quantile,
                            **kwargs)
@@ -2262,10 +2250,10 @@ def _apply(self, func, **kwargs):
 
             # if we have a string function name, wrap it
             if isinstance(func, compat.string_types):
-                cfunc = getattr(_window, func, None)
+                cfunc = getattr(libwindow, func, None)
                 if cfunc is None:
                     raise ValueError("we do not support this function "
-                                     "in _window.{0}".format(func))
+                                     "in libwindow.{func}".format(func=func))
 
                 def func(arg):
                     return cfunc(arg, self.com, int(self.adjust),
@@ -2300,9 +2288,9 @@ def var(self, bias=False, *args, **kwargs):
         nv.validate_window_func('var', args, kwargs)
 
         def f(arg):
-            return _window.ewmcov(arg, arg, self.com, int(self.adjust),
-                                  int(self.ignore_na), int(self.min_periods),
-                                  int(bias))
+            return libwindow.ewmcov(arg, arg, self.com, int(self.adjust),
+                                    int(self.ignore_na), int(self.min_periods),
+                                    int(bias))
 
         return self._apply(f, **kwargs)
 
@@ -2320,9 +2308,10 @@ def cov(self, other=None, pairwise=None, bias=False, **kwargs):
         def _get_cov(X, Y):
             X = self._shallow_copy(X)
             Y = self._shallow_copy(Y)
-            cov = _window.ewmcov(X._prep_values(), Y._prep_values(), self.com,
-                                 int(self.adjust), int(self.ignore_na),
-                                 int(self.min_periods), int(bias))
+            cov = libwindow.ewmcov(X._prep_values(), Y._prep_values(),
+                                   self.com, int(self.adjust),
+                                   int(self.ignore_na), int(self.min_periods),
+                                   int(bias))
             return X._wrap_result(cov)
 
         return _flex_binary_moment(self._selected_obj, other._selected_obj,
@@ -2344,10 +2333,10 @@ def _get_corr(X, Y):
             Y = self._shallow_copy(Y)
 
             def _cov(x, y):
-                return _window.ewmcov(x, y, self.com, int(self.adjust),
-                                      int(self.ignore_na),
-                                      int(self.min_periods),
-                                      1)
+                return libwindow.ewmcov(x, y, self.com, int(self.adjust),
+                                        int(self.ignore_na),
+                                        int(self.min_periods),
+                                        1)
 
             x_values = X._prep_values()
             y_values = Y._prep_values()

pandas/tests/scalar/interval/test_interval.py

@@ -1,11 +1,11 @@
 from __future__ import division
 
 import numpy as np
-from pandas import Interval, Timestamp, Timedelta
-import pandas.core.common as com
-
 import pytest
 
+from pandas import Interval, Timedelta, Timestamp
+import pandas.core.common as com
+
 
 @pytest.fixture
 def interval():

pandas/tests/scalar/period/test_asfreq.py

@@ -1,11 +1,11 @@
 import pytest
 
+from pandas._libs.tslibs.frequencies import (
+    INVALID_FREQ_ERR_MSG, _period_code_map)
 from pandas.errors import OutOfBoundsDatetime
 
-import pandas as pd
 from pandas import Period, offsets
 from pandas.util import testing as tm
-from pandas._libs.tslibs.frequencies import _period_code_map
 
 
 class TestFreqConversion(object):
@@ -328,13 +328,13 @@ def test_conv_weekly(self):
 
         assert ival_W.asfreq('W') == ival_W
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             ival_W.asfreq('WK')
 
     def test_conv_weekly_legacy(self):
         # frequency conversion tests: from Weekly Frequency
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             Period(freq='WK', year=2007, month=1, day=1)
 
@@ -741,11 +741,11 @@ def test_asfreq_MS(self):
 
         assert initial.asfreq(freq="M", how="S") == Period('2013-01', 'M')
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             initial.asfreq(freq="MS", how="S")
 
         with pytest.raises(ValueError, match=msg):
-            pd.Period('2013-01', 'MS')
+            Period('2013-01', 'MS')
 
         assert _period_code_map.get("MS") is None

pandas/tests/scalar/period/test_period.py

@@ -1,20 +1,21 @@
-import pytest
+from datetime import date, datetime, timedelta
 
-import pytz
 import numpy as np
-from datetime import datetime, date, timedelta
-
-import pandas as pd
-from pandas import Timedelta, NaT, Period, Timestamp, offsets
-import pandas.util.testing as tm
-import pandas.core.indexes.period as period
-from pandas.compat import text_type, iteritems
-from pandas.compat.numpy import np_datetime64_compat
+import pytest
+import pytz
 
 from pandas._libs.tslibs import iNaT, period as libperiod
 from pandas._libs.tslibs.ccalendar import DAYS, MONTHS
+from pandas._libs.tslibs.frequencies import INVALID_FREQ_ERR_MSG
 from pandas._libs.tslibs.parsing import DateParseError
 from pandas._libs.tslibs.timezones import dateutil_gettz, maybe_get_tz
+from pandas.compat import iteritems, text_type
+from pandas.compat.numpy import np_datetime64_compat
+
+import pandas as pd
+from pandas import NaT, Period, Timedelta, Timestamp, offsets
+import pandas.core.indexes.period as period
+import pandas.util.testing as tm
 
 
 class TestPeriodConstruction(object):
@@ -712,7 +713,7 @@ def test_period_deprecated_freq(self):
                  "U": ["MICROSECOND", "MICROSECONDLY", "microsecond"],
                  "N": ["NANOSECOND", "NANOSECONDLY", "nanosecond"]}
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         for exp, freqs in iteritems(cases):
             for freq in freqs:
                 with pytest.raises(ValueError, match=msg):
@@ -851,7 +852,7 @@ def test_properties_weekly_legacy(self):
         exp = Period(freq='W', year=2012, month=2, day=1)
         assert exp.days_in_month == 29
 
-        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        msg = INVALID_FREQ_ERR_MSG
         with pytest.raises(ValueError, match=msg):
             Period(freq='WK', year=2007, month=1, day=7)
 

pandas/tests/scalar/test_nat.py

@@ -1,15 +1,16 @@
-import pytest
-
 from datetime import datetime, timedelta
-import pytz
 
 import numpy as np
-from pandas import (NaT, Index, Timestamp, Timedelta, Period,
-                    DatetimeIndex,
-                    TimedeltaIndex, Series, isna)
+import pytest
+import pytz
+
+from pandas._libs.tslib import iNaT
+
+from pandas import (
+    DatetimeIndex, Index, NaT, Period, Series, Timedelta, TimedeltaIndex,
+    Timestamp, isna)
 from pandas.core.arrays import PeriodArray
 from pandas.util import testing as tm
-from pandas._libs.tslib import iNaT
 
 
 @pytest.mark.parametrize('nat, idx', [(Timestamp('NaT'), DatetimeIndex),