Update the new 2022 black syntax (#360)

Black is now out of beta and has introduced a small change in the
syntax, removing white space around `**` operators. They also now
promise to only update syntax like this at most once a year. Seems
reasonable and not a lot of work to keep up to date without pinning
black.

Author: leouieda

doc/gallery_src/blockreduce_weights_mean.py

@@ -49,7 +49,7 @@
 # It's important that the weights are given as 1/sigma**2 for the uncertainty
 # propagation. In this case, you should not use verde.variance_to_weights
 # because it would normalize the weights.
-weights = 1 / data.std_up ** 2
+weights = 1 / data.std_up**2
 reducer = vd.BlockMean(spacing, center_coordinates=True)
 # First produce the weighted variance weights
 variance_weights = reducer.filter(coordinates, data.velocity_up, weights)[-1]

doc/gallery_src/spline_weights.py

@@ -47,7 +47,7 @@
 train, test = vd.train_test_split(
     projection(*coordinates),
     data.velocity_up,
-    weights=1 / data.std_up ** 2,
+    weights=1 / data.std_up**2,
     random_state=0,
 )
 # Fit the model on the training set

doc/gallery_src/vector_trend.py

@@ -31,7 +31,7 @@
 # [Trend(...)]*2 as an argument to Vector. This creates references to the same
 # Trend instance and will mess up the fitting.
 trend = vd.Vector([vd.Trend(degree=2) for i in range(2)])
-weights = vd.variance_to_weights((data.std_east ** 2, data.std_north ** 2))
+weights = vd.variance_to_weights((data.std_east**2, data.std_north**2))
 trend.fit(
     coordinates=(data.longitude, data.latitude),
     data=(data.velocity_east, data.velocity_north),

doc/tutorials_src/vectors.py

@@ -69,7 +69,7 @@
 block_coords, block_data, block_weights = reducer.filter(
     coordinates=proj_coords,
     data=(data.velocity_east, data.velocity_north),
-    weights=(1 / data.std_east ** 2, 1 / data.std_north ** 2),
+    weights=(1 / data.std_east**2, 1 / data.std_north**2),
 )
 print(len(block_data), len(block_weights))
 
@@ -124,7 +124,7 @@
 trend.fit(
     coordinates=proj_coords,
     data=(data.velocity_east, data.velocity_north),
-    weights=(1 / data.std_east ** 2, 1 / data.std_north ** 2),
+    weights=(1 / data.std_east**2, 1 / data.std_north**2),
 )
 
 ###############################################################################
@@ -213,7 +213,7 @@
 train, test = vd.train_test_split(
     coordinates=proj_coords,
     data=(data.velocity_east, data.velocity_north),
-    weights=(1 / data.std_east ** 2, 1 / data.std_north ** 2),
+    weights=(1 / data.std_east**2, 1 / data.std_north**2),
     random_state=1,
 )
 

doc/tutorials_src/weights.py

@@ -153,7 +153,7 @@ def plot_data(coordinates, velocity, weights, title_data, title_weights):
 # weights.
 
 # We'll use 1 over the squared data uncertainty as our input weights.
-data["weights"] = 1 / data.std_up ** 2
+data["weights"] = 1 / data.std_up**2
 
 # By default, BlockMean assumes that weights are not related to uncertainties
 coordinates, velocity, weights = mean.filter(

verde/spline.py

@@ -509,11 +509,11 @@ def warn_weighted_exact_solution(spline, weights):
 
 def greens_func(east, north, mindist):
     "Calculate the Green's function for the Bi-Harmonic Spline"
-    distance = np.sqrt(east ** 2 + north ** 2)
+    distance = np.sqrt(east**2 + north**2)
     # The mindist factor helps avoid singular matrices when the force and
     # computation point are too close
     distance += mindist
-    return (distance ** 2) * (np.log(distance) - 1)
+    return (distance**2) * (np.log(distance) - 1)
 
 
 def predict_numpy(east, north, force_east, force_north, mindist, forces, result):

verde/tests/test_blockreduce.py

@@ -244,7 +244,7 @@ def test_blockmean_uncertainty_weights():
     uncertainty = np.ones_like(data)
     # Set a higher uncertainty for the first block
     uncertainty[:2, :2] = 2
-    weights = 1 / uncertainty ** 2
+    weights = 1 / uncertainty**2
     reducer = BlockMean(spacing=1, uncertainty=True)
     # Uncertainty propagation can only work if weights are given
     with pytest.raises(ValueError):
@@ -269,7 +269,7 @@ def test_blockmean_variance_weights():
     uncertainty = np.ones_like(data)
     # Set a higher uncertainty for the first block
     uncertainty[:2, :2] = 2
-    weights = 1 / uncertainty ** 2
+    weights = 1 / uncertainty**2
     reducer = BlockMean(spacing=1, uncertainty=False)
     block_coords, block_data, block_weights = reducer.filter(coords, data, weights)
     assert len(block_coords[0]) == 4

verde/tests/test_minimal.py

@@ -36,7 +36,7 @@ def test_minimal_integration_2d_gps():
     train, test = train_test_split(
         coordinates=proj_coords,
         data=(data.velocity_east, data.velocity_north),
-        weights=(1 / data.std_east ** 2, 1 / data.std_north ** 2),
+        weights=(1 / data.std_east**2, 1 / data.std_north**2),
         random_state=1,
     )
     chain = Chain(

verde/tests/test_projections.py

@@ -18,7 +18,7 @@
 
 def projection(longitude, latitude):
     "Dummy projection"
-    return longitude ** 2, latitude ** 2
+    return longitude**2, latitude**2
 
 
 @pytest.mark.parametrize(

verde/tests/test_utils.py

@@ -74,7 +74,7 @@ def test_kdtree():
 def test_grid_to_table_order():
     "Check that coordinates are in the right order when converting to tables"
     lon, lat = grid_coordinates(region=(1, 10, -10, -1), shape=(3, 4))
-    data = lon ** 2
+    data = lon**2
     # If the DataArray is created with coords in an order that doesn't match
     # the dims (which is valid), we were getting it wrong because we were
     # relying on the order of the coords instead of dims. This test would have