Fix all flake8 issues under default settings

Author: Zac-HD

xarray/backends/__init__.py

@@ -11,3 +11,14 @@
 from .scipy_ import ScipyDataStore
 from .h5netcdf_ import H5NetCDFStore
 from .zarr import ZarrStore
+
+__all__ = [
+    'AbstractDataStore',
+    'InMemoryDataStore',
+    'NetCDF4DataStore',
+    'PydapDataStore',
+    'NioDataStore',
+    'ScipyDataStore',
+    'H5NetCDFStore',
+    'ZarrStore',
+]

xarray/core/combine.py

@@ -9,7 +9,8 @@
 from .alignment import align
 from .merge import merge
 from .pycompat import iteritems, OrderedDict, basestring
-from .variable import Variable, as_variable, IndexVariable, concat as concat_vars
+from .variable import Variable, as_variable, IndexVariable, \
+    concat as concat_vars
 
 
 def concat(objs, dim=None, data_vars='all', coords='different',
@@ -103,12 +104,12 @@ def concat(objs, dim=None, data_vars='all', coords='different',
 
     if mode is not None:
         raise ValueError('`mode` is no longer a valid argument to '
-                         'xarray.concat; it has been split into the `data_vars` '
-                         'and `coords` arguments')
+                         'xarray.concat; it has been split into the '
+                         '`data_vars` and `coords` arguments')
     if concat_over is not None:
         raise ValueError('`concat_over` is no longer a valid argument to '
-                         'xarray.concat; it has been split into the `data_vars` '
-                         'and `coords` arguments')
+                         'xarray.concat; it has been split into the '
+                         '`data_vars` and `coords` arguments')
 
     if isinstance(first_obj, DataArray):
         f = _dataarray_concat
@@ -166,8 +167,8 @@ def process_subset_opt(opt, subset):
                     if k not in concat_over:
                         # Compare the variable of all datasets vs. the one
                         # of the first dataset. Perform the minimum amount of
-                        # loads in order to avoid multiple loads from disk while
-                        # keeping the RAM footprint low.
+                        # loads in order to avoid multiple loads from disk
+                        # while keeping the RAM footprint low.
                         v_lhs = datasets[0].variables[k].load()
                         # We'll need to know later on if variables are equal.
                         computed = []
@@ -199,11 +200,11 @@ def process_subset_opt(opt, subset):
                 if subset == 'coords':
                     raise ValueError(
                         'some variables in coords are not coordinates on '
-                        'the first dataset: %s' % invalid_vars)
+                        'the first dataset: %s' % (invalid_vars,))
                 else:
                     raise ValueError(
-                        'some variables in data_vars are not data variables on '
-                        'the first dataset: %s' % invalid_vars)
+                        'some variables in data_vars are not data variables '
+                        'on the first dataset: %s' % (invalid_vars,))
             concat_over.update(opt)
 
     process_subset_opt(data_vars, 'data_vars')
@@ -376,8 +377,8 @@ def auto_combine(datasets,
     This method attempts to combine a list of datasets into a single entity by
     inspecting metadata and using a combination of concat and merge.
 
-    It does not concatenate along more than one dimension or sort data under any
-    circumstances. It does align coordinates, but different variables on
+    It does not concatenate along more than one dimension or sort data under
+    any circumstances. It does align coordinates, but different variables on
     datasets can cause it to fail under some scenarios. In complex cases, you
     may need to clean up your data and use ``concat``/``merge`` explicitly.
 
@@ -391,9 +392,9 @@ def auto_combine(datasets,
         Dataset objects to merge.
     concat_dim : str or DataArray or Index, optional
         Dimension along which to concatenate variables, as used by
-        :py:func:`xarray.concat`. You only need to provide this argument if the
-        dimension along which you want to concatenate is not a dimension in
-        the original datasets, e.g., if you want to stack a collection of
+        :py:func:`xarray.concat`. You only need to provide this argument if
+        the dimension along which you want to concatenate is not a dimension
+        in the original datasets, e.g., if you want to stack a collection of
         2D arrays along a third dimension.
         By default, xarray attempts to infer this argument by examining
         component files. Set ``concat_dim=None`` explicitly to disable

xarray/core/computation.py

@@ -1,4 +1,5 @@
-"""Functions for applying functions that act on arrays to xarray's labeled data.
+"""
+Functions for applying functions that act on arrays to xarray's labeled data.
 
 NOT PUBLIC API.
 """
@@ -247,8 +248,8 @@ def assert_and_return_exact_match(all_keys):
     for keys in all_keys[1:]:
         if keys != first_keys:
             raise ValueError(
-                'exact match required for all data variable names, but %r != %r'
-                % (keys, first_keys))
+                'exact match required for all data variable names, '
+                'but %r != %r' % (keys, first_keys))
     return first_keys
 
 
@@ -482,9 +483,10 @@ def broadcast_compat_data(variable, broadcast_dims, core_dims):
     set_old_dims = set(old_dims)
     missing_core_dims = [d for d in core_dims if d not in set_old_dims]
     if missing_core_dims:
-        raise ValueError('operand to apply_ufunc has required core dimensions '
-                         '%r, but some of these are missing on the input '
-                         'variable:  %r' % (list(core_dims), missing_core_dims))
+        raise ValueError(
+            'operand to apply_ufunc has required core dimensions %r, but '
+            'some of these are missing on the input variable:  %r'
+            % (list(core_dims), missing_core_dims))
 
     set_new_dims = set(new_dims)
     unexpected_dims = [d for d in old_dims if d not in set_new_dims]
@@ -551,9 +553,11 @@ def apply_variable_ufunc(func, *args, **kwargs):
             input_dims = [broadcast_dims + dims
                           for dims in signature.input_core_dims]
             numpy_func = func
-            func = lambda *arrays: _apply_with_dask_atop(
-                numpy_func, arrays, input_dims, output_dims, signature,
-                output_dtypes, output_sizes)
+
+            def func(*arrays):
+                return _apply_with_dask_atop(
+                    numpy_func, arrays, input_dims, output_dims,
+                    signature, output_dtypes, output_sizes)
         elif dask == 'allowed':
             pass
         else:
@@ -597,8 +601,8 @@ def _apply_with_dask_atop(func, args, input_dims, output_dims, signature,
     new_dims = signature.all_output_core_dims - signature.all_input_core_dims
     if any(dim not in output_sizes for dim in new_dims):
         raise ValueError("when using dask='parallelized' with apply_ufunc, "
-                         'output core dimensions not found on inputs must have '
-                         'explicitly set sizes with ``output_sizes``: {}'
+                         'output core dimensions not found on inputs must '
+                         'have explicitly set sizes with ``output_sizes``: {}'
                          .format(new_dims))
 
     for n, (data, core_dims) in enumerate(
@@ -762,9 +766,9 @@ def apply_ufunc(func, *args, **kwargs):
     output_dtypes : list of dtypes, optional
         Optional list of output dtypes. Only used if dask='parallelized'.
     output_sizes : dict, optional
-        Optional mapping from dimension names to sizes for outputs. Only used if
-        dask='parallelized' and new dimensions (not found on inputs) appear on
-        outputs.
+        Optional mapping from dimension names to sizes for outputs. Only used
+        if dask='parallelized' and new dimensions (not found on inputs) appear
+        on outputs.
 
     Returns
     -------
@@ -844,7 +848,7 @@ def earth_mover_distance(first_samples,
     ----------
     .. [1] http://docs.scipy.org/doc/numpy/reference/ufuncs.html
     .. [2] http://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html
-    """
+    """  # noqa: E501  # don't error on that URL one line up
     from .groupby import GroupBy
     from .dataarray import DataArray
     from .variable import Variable

xarray/core/coordinates.py

@@ -107,7 +107,7 @@ def _merge_inplace(self, other):
             # don't include indexes in priority_vars, because we didn't align
             # first
             priority_vars = OrderedDict(
-                (k, v) for k, v in self.variables.items() if k not in self.dims)
+                kv for kv in self.variables.items() if kv[0] not in self.dims)
             variables = merge_coords_for_inplace_math(
                 [self.variables, other.variables], priority_vars=priority_vars)
             yield

xarray/core/dataarray.py

@@ -316,7 +316,7 @@ def _to_dataset_whole(self, name=None, shallow_copy=True):
         if name in self.coords:
             raise ValueError('cannot create a Dataset from a DataArray with '
                              'the same name as one of its coordinates')
-        # use private APIs here for speed: this is called by _to_temp_dataset(),
+        # use private APIs for speed: this is called by _to_temp_dataset(),
         # which is used in the guts of a lot of operations (e.g., reindex)
         variables = self._coords.copy()
         variables[name] = self.variable
@@ -428,9 +428,9 @@ def to_index(self):
     def dims(self):
         """Tuple of dimension names associated with this array.
 
-        Note that the type of this property is inconsistent with `Dataset.dims`.
-        See `Dataset.sizes` and `DataArray.sizes` for consistently named
-        properties.
+        Note that the type of this property is inconsistent with
+        `Dataset.dims`.  See `Dataset.sizes` and `DataArray.sizes` for
+        consistently named properties.
         """
         return self.variable.dims
 
@@ -868,12 +868,11 @@ def reindex(self, method=None, tolerance=None, copy=True, **indexers):
             Maximum distance between original and new labels for inexact
             matches. The values of the index at the matching locations most
             satisfy the equation ``abs(index[indexer] - target) <= tolerance``.
-            Requires pandas>=0.17.
         **indexers : dict
             Dictionary with keys given by dimension names and values given by
-            arrays of coordinates tick labels. Any mis-matched coordinate values
-            will be filled in with NaN, and any mis-matched dimension names will
-            simply be ignored.
+            arrays of coordinates tick labels. Any mis-matched coordinate
+            values will be filled in with NaN, and any mis-matched dimension
+            names will simply be ignored.
 
         Returns
         -------
@@ -943,8 +942,8 @@ def swap_dims(self, dims_dict):
         return self._from_temp_dataset(ds)
 
     def expand_dims(self, dim, axis=None):
-        """Return a new object with an additional axis (or axes) inserted at the
-        corresponding position in the array shape.
+        """Return a new object with an additional axis (or axes) inserted at
+        the corresponding position in the array shape.
 
         If dim is already a scalar coordinate, it will be promoted to a 1D
         coordinate consisting of a single value.
@@ -970,16 +969,17 @@ def expand_dims(self, dim, axis=None):
         return self._from_temp_dataset(ds)
 
     def set_index(self, append=False, inplace=False, **indexes):
-        """Set DataArray (multi-)indexes using one or more existing coordinates.
+        """Set DataArray (multi-)indexes using one or more existing
+        coordinates.
 
         Parameters
         ----------
         append : bool, optional
             If True, append the supplied index(es) to the existing index(es).
             Otherwise replace the existing index(es) (default).
         inplace : bool, optional
-            If True, set new index(es) in-place. Otherwise, return a new DataArray
-            object.
+            If True, set new index(es) in-place. Otherwise, return a new
+            DataArray object.
         **indexes : {dim: index, ...}
             Keyword arguments with names matching dimensions and values given
             by (lists of) the names of existing coordinates or variables to set
@@ -988,7 +988,7 @@ def set_index(self, append=False, inplace=False, **indexes):
         Returns
         -------
         obj : DataArray
-            Another dataarray, with this dataarray's data but replaced coordinates.
+            Another dataarray, with this data but replaced coordinates.
 
         See Also
         --------
@@ -1607,9 +1607,9 @@ def from_series(cls, series):
         """Convert a pandas.Series into an xarray.DataArray.
 
         If the series's index is a MultiIndex, it will be expanded into a
-        tensor product of one-dimensional coordinates (filling in missing values
-        with NaN). Thus this operation should be the inverse of the `to_series`
-        method.
+        tensor product of one-dimensional coordinates (filling in missing
+        values with NaN). Thus this operation should be the inverse of the
+        `to_series` method.
         """
         # TODO: add a 'name' parameter
         name = series.name
@@ -2089,16 +2089,16 @@ def quantile(self, q, dim=None, interpolation='linear', keep_attrs=False):
         numpy.nanpercentile, pandas.Series.quantile, Dataset.quantile
         """
 
-        ds = self._to_temp_dataset().quantile(q, dim=dim, keep_attrs=keep_attrs,
-                                              interpolation=interpolation)
+        ds = self._to_temp_dataset().quantile(
+            q, dim=dim, keep_attrs=keep_attrs, interpolation=interpolation)
         return self._from_temp_dataset(ds)
 
     def rank(self, dim, pct=False, keep_attrs=False):
         """Ranks the data.
 
         Equal values are assigned a rank that is the average of the ranks that
-        would have been otherwise assigned to all of the values within that set.
-        Ranks begin at 1, not 0. If pct is True, computes percentage ranks.
+        would have been otherwise assigned to all of the values within that
+        set.  Ranks begin at 1, not 0. If pct, computes percentage ranks.
 
         NaNs in the input array are returned as NaNs.
 

xarray/core/extensions.py

@@ -27,9 +27,9 @@ def __get__(self, obj, cls):
         try:
             accessor_obj = self._accessor(obj)
         except AttributeError:
-            # __getattr__ on data object will swallow any AttributeErrors raised
-            # when initializing the accessor, so we need to raise as something
-            # else (GH933):
+            # __getattr__ on data object will swallow any AttributeErrors
+            # raised when initializing the accessor, so we need to raise as
+            # something else (GH933):
             msg = 'error initializing %r accessor.' % self._name
             if PY2:
                 msg += ' Full traceback:\n' + traceback.format_exc()

xarray/core/groupby.py

@@ -550,8 +550,8 @@ def reduce(self, func, dim=None, axis=None, keep_attrs=False,
         ----------
         func : function
             Function which can be called in the form
-            `func(x, axis=axis, **kwargs)` to return the result of collapsing an
-            np.ndarray over an integer valued axis.
+            `func(x, axis=axis, **kwargs)` to return the result of collapsing
+            an np.ndarray over an integer valued axis.
         dim : str or sequence of str, optional
             Dimension(s) over which to apply `func`.
         axis : int or sequence of int, optional
@@ -632,8 +632,8 @@ def reduce(self, func, dim=None, keep_attrs=False, **kwargs):
         ----------
         func : function
             Function which can be called in the form
-            `func(x, axis=axis, **kwargs)` to return the result of collapsing an
-            np.ndarray over an integer valued axis.
+            `func(x, axis=axis, **kwargs)` to return the result of collapsing
+            an np.ndarray over an integer valued axis.
         dim : str or sequence of str, optional
             Dimension(s) over which to apply `func`.
         axis : int or sequence of int, optional

xarray/core/indexing.py

@@ -125,17 +125,17 @@ def convert_label_indexer(index, label, index_name='', method=None,
                                       _try_get_item(label.stop),
                                       _try_get_item(label.step))
         if not isinstance(indexer, slice):
-            # unlike pandas, in xarray we never want to silently convert a slice
-            # indexer into an array indexer
+            # unlike pandas, in xarray we never want to silently convert a
+            # slice indexer into an array indexer
             raise KeyError('cannot represent labeled-based slice indexer for '
                            'dimension %r with a slice over integer positions; '
                            'the index is unsorted or non-unique' % index_name)
 
     elif is_dict_like(label):
         is_nested_vals = _is_nested_tuple(tuple(label.values()))
         if not isinstance(index, pd.MultiIndex):
-            raise ValueError('cannot use a dict-like object for selection on a '
-                             'dimension that does not have a MultiIndex')
+            raise ValueError('cannot use a dict-like object for selection on '
+                             'a dimension that does not have a MultiIndex')
         elif len(label) == index.nlevels and not is_nested_vals:
             indexer = index.get_loc(tuple((label[k] for k in index.names)))
         else:

xarray/core/merge.py

@@ -507,8 +507,9 @@ def merge(objects, compat='no_conflicts', join='outer'):
     from .dataarray import DataArray
     from .dataset import Dataset
 
-    dict_like_objects = [obj.to_dataset() if isinstance(obj, DataArray) else obj
-                         for obj in objects]
+    dict_like_objects = [
+        obj.to_dataset() if isinstance(obj, DataArray) else obj
+        for obj in objects]
 
     variables, coord_names, dims = merge_core(dict_like_objects, compat, join)
     merged = Dataset._construct_direct(variables, coord_names, dims)
@@ -549,4 +550,5 @@ def dataset_merge_method(dataset, other, overwrite_vars, compat, join):
 
 def dataset_update_method(dataset, other):
     """Guts of the Dataset.update method"""
-    return merge_core([dataset, other], priority_arg=1, indexes=dataset.indexes)
+    return merge_core([dataset, other], priority_arg=1,
+                      indexes=dataset.indexes)

xarray/core/npcompat.py

@@ -33,8 +33,8 @@ def _replace_nan(a, val):
             If `a` is of inexact type, return a copy of `a` with the NaNs
             replaced by the fill value, otherwise return `a`.
         mask: {bool, None}
-            If `a` is of inexact type, return a boolean mask marking locations of
-            NaNs, otherwise return None.
+            If `a` is of inexact type, return a boolean mask marking locations
+            of NaNs, otherwise return None.
 
         """
         is_new = not isinstance(a, np.ndarray)
@@ -206,7 +206,7 @@ def flip(m, axis):
         -----
         flip(m, 0) is equivalent to flipud(m).
         flip(m, 1) is equivalent to fliplr(m).
-        flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+        flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at index n.
 
         Examples
         --------

xarray/core/rolling.py

@@ -87,7 +87,8 @@ def __repr__(self):
         """provide a nice str repr of our rolling object"""
 
         attrs = ["{k}->{v}".format(k=k, v=getattr(self, k))
-                 for k in self._attributes if getattr(self, k, None) is not None]
+                 for k in self._attributes
+                 if getattr(self, k, None) is not None]
         return "{klass} [{attrs}]".format(klass=self.__class__.__name__,
                                           attrs=','.join(attrs))