Remove problematic backslashes

etienneschalk · etienneschalk · commit 85f6ee4f2d9d · 2024-02-05T23:39:18.000+01:00
diff --git a/xarray/backends/api.py b/xarray/backends/api.py
@@ -419,8 +419,8 @@ def open_dataset(
         ends with .gz, in which case the file is gunzipped and opened with
         scipy.io.netcdf (only netCDF3 supported). Byte-strings or file-like
         objects are opened by scipy.io.netcdf (netCDF3) or h5py (netCDF4/HDF).
-    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio", \
-        "zarr", None}, installed backend \
+    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio",,
+        "zarr", None}, installed backend,
         or subclass of xarray.backends.BackendEntrypoint, optional
         Engine to use when reading files. If not provided, the default engine
         is chosen based on available dependencies, with a preference for
@@ -626,8 +626,8 @@ def open_dataarray(
         ends with .gz, in which case the file is gunzipped and opened with
         scipy.io.netcdf (only netCDF3 supported). Byte-strings or file-like
         objects are opened by scipy.io.netcdf (netCDF3) or h5py (netCDF4/HDF).
-    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio", \
-        "zarr", None}, installed backend \
+    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio",,
+        "zarr", None}, installed backend,
         or subclass of xarray.backends.BackendEntrypoint, optional
         Engine to use when reading files. If not provided, the default engine
         is chosen based on available dependencies, with a preference for
@@ -791,13 +791,15 @@ def open_dataarray(
 def open_mfdataset(
     paths: str | NestedSequence[str | os.PathLike],
     chunks: T_Chunks | None = None,
-    concat_dim: str
-    | DataArray
-    | Index
-    | Sequence[str]
-    | Sequence[DataArray]
-    | Sequence[Index]
-    | None = None,
+    concat_dim: (
+        str
+        | DataArray
+        | Index
+        | Sequence[str]
+        | Sequence[DataArray]
+        | Sequence[Index]
+        | None
+    ) = None,
     compat: CompatOptions = "no_conflicts",
     preprocess: Callable[[Dataset], Dataset] | None = None,
     engine: T_Engine | None = None,
@@ -847,7 +849,7 @@ def open_mfdataset(
     combine : {"by_coords", "nested"}, optional
         Whether ``xarray.combine_by_coords`` or ``xarray.combine_nested`` is used to
         combine all the data. Default is to use ``xarray.combine_by_coords``.
-    compat : {"identical", "equals", "broadcast_equals", \
+    compat : {"identical", "equals", "broadcast_equals",,
               "no_conflicts", "override"}, default: "no_conflicts"
         String indicating how to compare variables of the same name for
         potential conflicts when merging:
@@ -866,8 +868,8 @@ def open_mfdataset(
         If provided, call this function on each dataset prior to concatenation.
         You can find the file-name from which each dataset was loaded in
         ``ds.encoding["source"]``.
-    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio", \
-        "zarr", None}, installed backend \
+    engine : {"netcdf4", "scipy", "pydap", "h5netcdf", "pynio",,
+        "zarr", None}, installed backend,
         or subclass of xarray.backends.BackendEntrypoint, optional
         Engine to use when reading files. If not provided, the default engine
         is chosen based on available dependencies, with a preference for
@@ -917,7 +919,7 @@ def open_mfdataset(
         Path of the file used to read global attributes from.
         By default global attributes are read from the first file provided,
         with wildcard matches sorted by filename.
-    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",,
                      "override"} or callable, default: "override"
         A callable or a string indicating how to combine attrs of the objects being
         merged:
@@ -1390,7 +1392,7 @@ def save_mfdataset(
     mode : {"w", "a"}, optional
         Write ("w") or append ("a") mode. If mode="w", any existing file at
         these locations will be overwritten.
-    format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT", \
+    format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT",,
               "NETCDF3_CLASSIC"}, optional
     **kwargs : additional arguments are passed along to ``to_netcdf``
 
diff --git a/xarray/core/combine.py b/xarray/core/combine.py
@@ -372,7 +372,7 @@ def _nested_combine(
 
 def combine_nested(
     datasets: DATASET_HYPERCUBE,
-    concat_dim: (str | DataArray | None | Sequence[str | DataArray | pd.Index | None]),
+    concat_dim: str | DataArray | None | Sequence[str | DataArray | pd.Index | None],
     compat: str = "no_conflicts",
     data_vars: str = "all",
     coords: str = "different",
@@ -413,7 +413,7 @@ def combine_nested(
         nested-list input along which to merge.
         Must be the same length as the depth of the list passed to
         ``datasets``.
-    compat : {"identical", "equals", "broadcast_equals", \
+    compat : {"identical", "equals", "broadcast_equals",
               "no_conflicts", "override"}, optional
         String indicating how to compare variables of the same name for
         potential merge conflicts:
@@ -448,7 +448,7 @@ def combine_nested(
         - "override": if indexes are of same size, rewrite indexes to be
           those of the first object with that dimension. Indexes for the same
           dimension must have the same size in all objects.
-    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",
                      "override"} or callable, default: "drop"
         A callable or a string indicating how to combine attrs of the objects being
         merged:
@@ -738,7 +738,7 @@ def combine_by_coords(
           those of the first object with that dimension. Indexes for the same
           dimension must have the same size in all objects.
 
-    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",
                      "override"} or callable, default: "no_conflicts"
         A callable or a string indicating how to combine attrs of the objects being
         merged:
diff --git a/xarray/core/computation.py b/xarray/core/computation.py
@@ -1,6 +1,7 @@
 """
 Functions for applying functions that act on arrays to xarray's labeled data.
 """
+
 from __future__ import annotations
 
 import functools
@@ -223,7 +224,7 @@ def build_output_coords_and_indexes(
     exclude_dims : set, optional
         Dimensions excluded from the operation. Coordinates along these
         dimensions are dropped.
-    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",
                      "override"} or callable, default: "drop"
         A callable or a string indicating how to combine attrs of the objects being
         merged:
@@ -731,9 +732,11 @@ def apply_variable_ufunc(
     output_dims = [broadcast_dims + out for out in signature.output_core_dims]
 
     input_data = [
-        broadcast_compat_data(arg, broadcast_dims, core_dims)
-        if isinstance(arg, Variable)
-        else arg
+        (
+            broadcast_compat_data(arg, broadcast_dims, core_dims)
+            if isinstance(arg, Variable)
+            else arg
+        )
         for arg, core_dims in zip(args, signature.input_core_dims)
     ]
 
@@ -931,7 +934,7 @@ def apply_ufunc(
         the style of NumPy universal functions [1]_ (if this is not the case,
         set ``vectorize=True``). If this function returns multiple outputs, you
         must set ``output_core_dims`` as well.
-    *args : Dataset, DataArray, DataArrayGroupBy, DatasetGroupBy, Variable, \
+    *args : Dataset, DataArray, DataArrayGroupBy, DatasetGroupBy, Variable,
         numpy.ndarray, dask.array.Array or scalar
         Mix of labeled and/or unlabeled arrays to which to apply the function.
     input_core_dims : sequence of sequence, optional
diff --git a/xarray/core/concat.py b/xarray/core/concat.py
@@ -148,7 +148,7 @@ def concat(
         - "override": if indexes are of same size, rewrite indexes to be
           those of the first object with that dimension. Indexes for the same
           dimension must have the same size in all objects.
-    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+    combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",
                      "override"} or callable, default: "override"
         A callable or a string indicating how to combine attrs of the objects being
         merged:
diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py
@@ -3437,7 +3437,7 @@ def interpolate_na(
         ----------
         dim : Hashable or None, optional
             Specifies the dimension along which to interpolate.
-        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", \
+        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial",
             "barycentric", "krogh", "pchip", "spline", "akima"}, default: "linear"
             String indicating which method to use for interpolation:
 
@@ -3995,7 +3995,7 @@ def to_netcdf(
             Write ('w') or append ('a') mode. If mode='w', any existing file at
             this location will be overwritten. If mode='a', existing variables
             will be overwritten.
-        format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT", \
+        format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT",
                   "NETCDF3_CLASSIC"}, optional
             File format for the resulting netCDF file:
 
@@ -4983,10 +4983,12 @@ def dot(
 
     def sortby(
         self,
-        variables: Hashable
-        | DataArray
-        | Sequence[Hashable | DataArray]
-        | Callable[[Self], Hashable | DataArray | Sequence[Hashable | DataArray]],
+        variables: (
+            Hashable
+            | DataArray
+            | Sequence[Hashable | DataArray]
+            | Callable[[Self], Hashable | DataArray | Sequence[Hashable | DataArray]]
+        ),
         ascending: bool = True,
     ) -> Self:
         """Sort object by labels or values (along an axis).
@@ -5232,7 +5234,7 @@ def differentiate(
         edge_order: Literal[1, 2] = 1,
         datetime_unit: DatetimeUnitOptions = None,
     ) -> Self:
-        """ Differentiate the array with the second order accurate central
+        """Differentiate the array with the second order accurate central
         differences.
 
         .. note::
@@ -5245,7 +5247,7 @@ def differentiate(
             The coordinate to be used to compute the gradient.
         edge_order : {1, 2}, default: 1
             N-th order accurate differences at the boundaries.
-        datetime_unit : {"W", "D", "h", "m", "s", "ms", \
+        datetime_unit : {"W", "D", "h", "m", "s", "ms",
                          "us", "ns", "ps", "fs", "as", None}, optional
             Unit to compute gradient. Only valid for datetime coordinate. "Y" and "M" are not available as
             datetime_unit.
@@ -5304,7 +5306,7 @@ def integrate(
         ----------
         coord : Hashable, or sequence of Hashable
             Coordinate(s) used for the integration.
-        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', \
+        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns',
                         'ps', 'fs', 'as', None}, optional
             Specify the unit if a datetime coordinate is used.
 
@@ -5361,7 +5363,7 @@ def cumulative_integrate(
         ----------
         coord : Hashable, or sequence of Hashable
             Coordinate(s) used for the integration.
-        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', \
+        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns',
                         'ps', 'fs', 'as', None}, optional
             Specify the unit if a datetime coordinate is used.
 
@@ -5596,14 +5598,12 @@ def pad(
         self,
         pad_width: Mapping[Any, int | tuple[int, int]] | None = None,
         mode: PadModeOptions = "constant",
-        stat_length: int
-        | tuple[int, int]
-        | Mapping[Any, tuple[int, int]]
-        | None = None,
-        constant_values: float
-        | tuple[float, float]
-        | Mapping[Any, tuple[float, float]]
-        | None = None,
+        stat_length: (
+            int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None
+        ) = None,
+        constant_values: (
+            float | tuple[float, float] | Mapping[Any, tuple[float, float]] | None
+        ) = None,
         end_values: int | tuple[int, int] | Mapping[Any, tuple[int, int]] | None = None,
         reflect_type: PadReflectOptions = None,
         keep_attrs: bool | None = None,
@@ -5625,7 +5625,7 @@ def pad(
             Mapping with the form of {dim: (pad_before, pad_after)}
             describing the number of values padded along each dimension.
             {dim: pad} is a shortcut for pad_before = pad_after = pad
-        mode : {"constant", "edge", "linear_ramp", "maximum", "mean", "median", \
+        mode : {"constant", "edge", "linear_ramp", "maximum", "mean", "median",
             "minimum", "reflect", "symmetric", "wrap"}, default: "constant"
             How to pad the DataArray (taken from numpy docs):
 
diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
@@ -2230,7 +2230,7 @@ def to_netcdf(
             Write ('w') or append ('a') mode. If mode='w', any existing file at
             this location will be overwritten. If mode='a', existing variables
             will be overwritten.
-        format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT", \
+        format : {"NETCDF4", "NETCDF4_CLASSIC", "NETCDF3_64BIT",,
                   "NETCDF3_CLASSIC"}, optional
             File format for the resulting netCDF file:
 
@@ -3801,7 +3801,7 @@ def interp(
             New coordinate can be a scalar, array-like or DataArray.
             If DataArrays are passed as new coordinates, their dimensions are
             used for the broadcasting. Missing values are skipped.
-        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", \
+        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial",,
             "barycentric", "krogh", "pchip", "spline", "akima"}, default: "linear"
             String indicating which method to use for interpolation:
 
@@ -4080,7 +4080,7 @@ def interp_like(
             Object with an 'indexes' attribute giving a mapping from dimension
             names to an 1d array-like, which provides coordinates upon
             which to index the variables in this dataset. Missing values are skipped.
-        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", \
+        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial",,
             "barycentric", "krogh", "pchip", "spline", "akima"}, default: "linear"
             String indicating which method to use for interpolation:
 
@@ -5646,7 +5646,7 @@ def merge(
         overwrite_vars : hashable or iterable of hashable, optional
             If provided, update variables of these name(s) without checking for
             conflicts in this dataset.
-        compat : {"identical", "equals", "broadcast_equals", \
+        compat : {"identical", "equals", "broadcast_equals",,
                   "no_conflicts", "override", "minimal"}, default: "no_conflicts"
             String indicating how to compare variables of the same name for
             potential conflicts:
@@ -5662,7 +5662,7 @@ def merge(
             - 'override': skip comparing and pick variable from first dataset
             - 'minimal': drop conflicting coordinates
 
-        join : {"outer", "inner", "left", "right", "exact", "override"}, \
+        join : {"outer", "inner", "left", "right", "exact", "override"},,
                default: "outer"
             Method for joining ``self`` and ``other`` along shared dimensions:
 
@@ -5677,7 +5677,7 @@ def merge(
         fill_value : scalar or dict-like, optional
             Value to use for newly missing values. If a dict-like, maps
             variable names (including coordinates) to fill values.
-        combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts", \
+        combine_attrs : {"drop", "identical", "no_conflicts", "drop_conflicts",,
                          "override"} or callable, default: "override"
             A callable or a string indicating how to combine attrs of the objects being
             merged:
@@ -6466,7 +6466,7 @@ def interpolate_na(
         ----------
         dim : Hashable or None, optional
             Specifies the dimension along which to interpolate.
-        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial", \
+        method : {"linear", "nearest", "zero", "slinear", "quadratic", "cubic", "polynomial",,
             "barycentric", "krogh", "pchip", "spline", "akima"}, default: "linear"
             String indicating which method to use for interpolation:
 
@@ -7487,7 +7487,7 @@ def from_dict(cls, d: Mapping[Any, Any]) -> Self:
         ----------
         d : dict-like
             Mapping with a minimum structure of
-                ``{"var_0": {"dims": [..], "data": [..]}, \
+                ``{"var_0": {"dims": [..], "data": [..]},,
                             ...}``
 
         Returns
@@ -8265,7 +8265,7 @@ def differentiate(
         edge_order: Literal[1, 2] = 1,
         datetime_unit: DatetimeUnitOptions | None = None,
     ) -> Self:
-        """ Differentiate with the second order accurate central
+        """Differentiate with the second order accurate central
         differences.
 
         .. note::
@@ -8278,7 +8278,7 @@ def differentiate(
             The coordinate to be used to compute the gradient.
         edge_order : {1, 2}, default: 1
             N-th order accurate differences at the boundaries.
-        datetime_unit : None or {"Y", "M", "W", "D", "h", "m", "s", "ms", \
+        datetime_unit : None or {"Y", "M", "W", "D", "h", "m", "s", "ms",,
             "us", "ns", "ps", "fs", "as", None}, default: None
             Unit to compute gradient. Only valid for datetime coordinate.
 
@@ -8346,7 +8346,7 @@ def integrate(
         ----------
         coord : hashable, or sequence of hashable
             Coordinate(s) used for the integration.
-        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', \
+        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns',,
                         'ps', 'fs', 'as', None}, optional
             Specify the unit if datetime coordinate is used.
 
@@ -8469,7 +8469,7 @@ def cumulative_integrate(
         ----------
         coord : hashable, or sequence of hashable
             Coordinate(s) used for the integration.
-        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns', \
+        datetime_unit : {'Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms', 'us', 'ns',,
                         'ps', 'fs', 'as', None}, optional
             Specify the unit if datetime coordinate is used.
 
@@ -8997,7 +8997,7 @@ def pad(
             Mapping with the form of {dim: (pad_before, pad_after)}
             describing the number of values padded along each dimension.
             {dim: pad} is a shortcut for pad_before = pad_after = pad
-        mode : {"constant", "edge", "linear_ramp", "maximum", "mean", "median", \
+        mode : {"constant", "edge", "linear_ramp", "maximum", "mean", "median",,
             "minimum", "reflect", "symmetric", "wrap"}, default: "constant"
             How to pad the DataArray (taken from numpy docs):
 
diff --git a/xarray/core/merge.py b/xarray/core/merge.py
diff --git a/xarray/core/resample.py b/xarray/core/resample.py
diff --git a/xarray/core/variable.py b/xarray/core/variable.py
