From 59e739089d9c9a8d4d62cd06870af492c74cbdef Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 5 Sep 2023 17:21:29 +0000 Subject: [PATCH] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- xarray/backends/netCDF4_.py | 16 +++-- xarray/coding/strings.py | 21 +++++-- xarray/coding/times.py | 41 ++++++++++-- xarray/coding/variables.py | 120 ++++++++++++++++++++++++++++++++---- xarray/conventions.py | 24 +++++++- xarray/core/dataarray.py | 2 +- xarray/core/variable.py | 29 ++++++--- 7 files changed, 210 insertions(+), 43 deletions(-) diff --git a/xarray/backends/netCDF4_.py b/xarray/backends/netCDF4_.py index 93f01524e48..d59a19b11b1 100644 --- a/xarray/backends/netCDF4_.py +++ b/xarray/backends/netCDF4_.py @@ -441,9 +441,14 @@ def open_store_variable(self, name, var): encoding["source"] = self._filename encoding["original_shape"] = var.shape encoding["dtype"] = var.dtype - return Variable(dimensions, data, attributes, encoding, - enum_meaning= enum_meaning, - enum_name=enum_name) + return Variable( + dimensions, + data, + attributes, + encoding, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) def get_variables(self): return FrozenDict( @@ -514,9 +519,8 @@ def prepare_variable( enum = None if variable.enum_meaning: enum = self.ds.createEnumType( - variable.dtype, - variable.enum_name, - variable.enum_meaning) + variable.dtype, variable.enum_name, variable.enum_meaning + ) if name in self.ds.variables: nc4_var = self.ds.variables[name] diff --git a/xarray/coding/strings.py b/xarray/coding/strings.py index 9e27fb36b14..88f132311b4 100644 --- a/xarray/coding/strings.py +++ b/xarray/coding/strings.py @@ -11,7 +11,6 @@ pop_to, safe_setitem, unpack, - unpack, ) from xarray.core import indexing from xarray.core.parallelcompat import get_chunked_array_type, is_chunked_array @@ -69,7 +68,9 @@ def encode(self, variable, name=None): # TODO: figure out how to handle this in a lazy way with dask data = encode_string_array(data, string_encoding) - return Variable(dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name + ) def decode(self, variable, name=None): dims, data, attrs, encoding, enum_meaning, enum_name = unpack(variable) @@ -79,7 +80,9 @@ def decode(self, variable, name=None): func = partial(decode_bytes_array, encoding=string_encoding) data = lazy_elemwise_func(data, func, np.dtype(object)) - return Variable(dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name + ) def decode_bytes_array(bytes_array, encoding="utf-8"): @@ -101,7 +104,9 @@ def ensure_fixed_length_bytes(var): if check_vlen_dtype(data.dtype) == bytes: # TODO: figure out how to handle this with dask data = np.asarray(data, dtype=np.string_) - return Variable(dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name + ) class CharacterArrayCoder(VariableCoder): @@ -118,7 +123,9 @@ def encode(self, variable, name=None): else: char_dim_name = f"string{data.shape[-1]}" dims = dims + (char_dim_name,) - return Variable(dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name + ) def decode(self, variable, name=None): dims, data, attrs, encoding, enum_meaning, enum_name = unpack(variable) @@ -127,7 +134,9 @@ def decode(self, variable, name=None): encoding["char_dim_name"] = dims[-1] dims = dims[:-1] data = char_to_bytes(data) - return Variable(dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, data, attrs, encoding, enum_meaning=enum_meaning, enum_name=enum_name + ) def bytes_to_char(arr): diff --git a/xarray/coding/times.py b/xarray/coding/times.py index ac9b64cfafc..c29dd0dc5b0 100644 --- a/xarray/coding/times.py +++ b/xarray/coding/times.py @@ -18,7 +18,6 @@ pop_to, safe_setitem, unpack, - unpack, ) from xarray.core import indexing from xarray.core.common import contains_cftime_datetimes, is_np_datetime_like @@ -710,7 +709,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: safe_setitem(attrs, "units", units, name=name) safe_setitem(attrs, "calendar", calendar, name=name) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -730,7 +737,15 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: ) data = lazy_elemwise_func(data, transform, dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -743,7 +758,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: data, units = encode_cf_timedelta(data, encoding.pop("units", None)) safe_setitem(attrs, "units", units, name=name) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -757,6 +780,14 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: dtype = np.dtype("timedelta64[ns]") data = lazy_elemwise_func(data, transform, dtype=dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable diff --git a/xarray/coding/variables.py b/xarray/coding/variables.py index 4bc3ee586f1..9dd39201edc 100644 --- a/xarray/coding/variables.py +++ b/xarray/coding/variables.py @@ -168,7 +168,15 @@ def lazy_elemwise_func(array, func: Callable, dtype: np.typing.DTypeLike): def unpack(var: Variable) -> T_VarTuple: - return var.dims, var.data, var.attrs.copy(), var.encoding.copy(), var.enum_meaning, var.enum_name, + return ( + var.dims, + var.data, + var.attrs.copy(), + var.encoding.copy(), + var.enum_meaning, + var.enum_name, + ) + def safe_setitem(dest, key: Hashable, value, name: T_Name = None): if key in dest: @@ -245,7 +253,15 @@ def encode(self, variable: Variable, name: T_Name = None): if not pd.isnull(fill_value) and not fv_exists: data = duck_array_ops.fillna(data, fill_value) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) def decode(self, variable: Variable, name: T_Name = None): dims, data, attrs, encoding, enum_meaning, enum_name = unpack(variable) @@ -281,7 +297,15 @@ def decode(self, variable: Variable, name: T_Name = None): ) data = lazy_elemwise_func(data, transform, dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -332,7 +356,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: if "scale_factor" in encoding: data /= pop_to(encoding, attrs, "scale_factor", name=name) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) def decode(self, variable: Variable, name: T_Name = None) -> Variable: _attrs = variable.attrs @@ -354,7 +386,15 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: ) data = lazy_elemwise_func(data, transform, dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -375,7 +415,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: attrs["_FillValue"] = new_fill data = duck_array_ops.astype(duck_array_ops.around(data), signed_dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -409,7 +457,15 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: stacklevel=3, ) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -426,7 +482,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: and np.issubdtype(variable.dtype, np.floating) ): attrs["_FillValue"] = variable.dtype.type(np.nan) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -447,7 +511,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: attrs["dtype"] = "bool" data = duck_array_ops.astype(data, dtype="i1", copy=True) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -458,7 +530,15 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: # needed for correct subsequent encoding encoding["dtype"] = attrs.pop("dtype") data = BoolTypeArray(data) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -473,7 +553,15 @@ def decode(self, variable: Variable, name: T_Name = None) -> Variable: dims, data, attrs, encoding, enum_meaning, enum_name = unpack(variable) if not data.dtype.isnative: data = NativeEndiannessArray(data) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable @@ -504,7 +592,15 @@ def encode(self, variable: Variable, name: T_Name = None) -> Variable: ) data = np.around(data) data = data.astype(dtype=dtype) - return Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) else: return variable diff --git a/xarray/conventions.py b/xarray/conventions.py index bce24c561ee..b9fd6315106 100644 --- a/xarray/conventions.py +++ b/xarray/conventions.py @@ -145,7 +145,15 @@ def ensure_dtype_not_object(var: Variable, name: T_Name = None) -> Variable: data = _copy_with_dtype(data, dtype=_infer_dtype(data, name)) assert data.dtype.kind != "O" or data.dtype.metadata - var = Variable(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + var = Variable( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) return var @@ -282,14 +290,24 @@ def decode_cf_variable( var = variables.BooleanCoder().decode(var) - dimensions, data, attributes, encoding, enum_meaning, enum_name = variables.unpack(var) + dimensions, data, attributes, encoding, enum_meaning, enum_name = variables.unpack( + var + ) encoding.setdefault("dtype", original_dtype) if not is_duck_dask_array(data): data = indexing.LazilyIndexedArray(data) - return Variable(dimensions, data, attributes, encoding=encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return Variable( + dimensions, + data, + attributes, + encoding=encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) def _update_bounds_attributes(variables: T_Variables) -> None: diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index 3698e0f5b76..e8192a117d7 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -656,7 +656,7 @@ def to_dataset( @property def enum_meaning(self) -> dict | None: return self.variable.enum_meaning - + @property def name(self) -> Hashable | None: """The name of this array.""" diff --git a/xarray/core/variable.py b/xarray/core/variable.py index bb877c8ddc4..e6674550123 100644 --- a/xarray/core/variable.py +++ b/xarray/core/variable.py @@ -335,15 +335,16 @@ class Variable(AbstractArray, NdimSizeLenMixin, VariableArithmetic): __slots__ = ("_dims", "_data", "_attrs", "_encoding", "_enum_name", "_enum_meaning") - def __init__(self, - dims, - data, - attrs=None, - encoding=None, - enum_meaning: dict[str, int] | None = None, - enum_name: str | None = None, - fastpath=False, - ): + def __init__( + self, + dims, + data, + attrs=None, + encoding=None, + enum_meaning: dict[str, int] | None = None, + enum_name: str | None = None, + fastpath=False, + ): """ Parameters ---------- @@ -1131,7 +1132,15 @@ def _replace( enum_meaning = copy.copy(self._enum_meaning) if enum_name is _default: enum_name = copy.copy(self._enum_name) - return type(self)(dims, data, attrs, encoding, fastpath=True, enum_meaning=enum_meaning, enum_name=enum_name) + return type(self)( + dims, + data, + attrs, + encoding, + fastpath=True, + enum_meaning=enum_meaning, + enum_name=enum_name, + ) def __copy__(self: T_Variable) -> T_Variable: return self._copy(deep=False)