[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

yt/geometry/coordinates/tests/test_sph_pixelization_pytestonly.py

@@ -1,7 +1,6 @@
 import numpy as np
 import pytest
 import unyt
-from numpy.typing import NDArray
 
 import yt
 from yt.data_objects.selection_objects.region import YTRegion
@@ -167,20 +166,19 @@ def makemasses(i, j, k):
     assert_rel_equal(expected_out, img.v, 5)
 
 
-
 @pytest.mark.parametrize("axis", [0, 1, 2])
 @pytest.mark.parametrize("shiftcenter", [True, False])
 @pytest.mark.parametrize("periodic", [True, False])
 @pytest.mark.parametrize("depth", [None, (1.0, "cm"), (5.0, "cm")])
-@pytest.mark.parametrize("hsmlfac", [0.2, 0.5, 1.0]) 
+@pytest.mark.parametrize("hsmlfac", [0.2, 0.5, 1.0])
 def test_sph_proj_pixelave_alongaxes(
     axis: int,
     shiftcenter: bool,
     periodic: bool,
     depth: float,
     hsmlfac: float,
 ) -> None:
-    # weighted and unweighted tested in one round: 
+    # weighted and unweighted tested in one round:
     # need weight map to downsample the baseline weighted map
     if shiftcenter:
         center = unyt.unyt_array(np.array((0.6, 0.5, 0.4)), "cm")
@@ -279,9 +277,8 @@ def makemasses(i, j, k):
     baseimg = resreduce_image(_baseimg, buff_size)
     _baseimg_wtd = baseprj_wtd.frb.data[("gas", "density")]
     _divimg = np.copy(baseimg.v)
-    _divimg[_divimg == 0.] = -1. # avoid div. by 0 test failures
-    baseimg_wtd = (resreduce_image(_baseimg * _baseimg_wtd.v, buff_size) 
-                   / _divimg)
+    _divimg[_divimg == 0.0] = -1.0  # avoid div. by 0 test failures
+    baseimg_wtd = resreduce_image(_baseimg * _baseimg_wtd.v, buff_size) / _divimg
 
     print(
         f"axis: {axis}, shiftcenter: {shiftcenter}, "
@@ -301,46 +298,48 @@ def makemasses(i, j, k):
     # subsampling with multiple particles is not quite at 4.
     # pixel values seem to converge more slowly though, so we test
     # mass conservation explicitly, and pixel agreement at low
-    # precision 
+    # precision
     assert_rel_equal(baseimg.v, testimg.v, 1)
     assert_rel_equal(np.sum(baseimg.v), np.sum(testimg.v), 2)
     assert_rel_equal(baseimg_wtd.v, testimg_wtd.v, 1)
 
 
 def test_massconservation_pixave():
-    bbox = np.array([[0., 3.], [0., 3.], [0., 3.]])
+    bbox = np.array([[0.0, 3.0], [0.0, 3.0], [0.0, 3.0]])
     pz = 1.5
     periodic = True
-    periods = 3.
+    periods = 3.0
     nrandom = 50
-    
+
     # random centers, three pixel size + hsml sets
     # test three cases in the backend routine
     rng = np.random.default_rng()
-    pxs = rng.uniform(0., 3., nrandom)
-    pys = rng.uniform(0., 3., nrandom)
+    pxs = rng.uniform(0.0, 3.0, nrandom)
+    pys = rng.uniform(0.0, 3.0, nrandom)
     # particles < pixels: overlap 1, 2x1, or 2x2 pixels
     hsmls1 = rng.uniform(0.01, 0.05, nrandom)
     outsize1 = (7, 7)
     # particles ~ pixels: typical 2x2 overlaps
     hsmls2 = rng.uniform(0.1, 0.25, nrandom)
     outsize2 = (7, 7)
-    # particles > pixels: 
+    # particles > pixels:
     hsmls3 = rng.uniform(0.07, 0.8, nrandom)
     outsize3 = (50, 50)
-    
-    for i, (hsmls, outsize) in enumerate([(hsmls1, outsize1),
-                                          (hsmls2, outsize2),
-                                          (hsmls3, outsize3),
-                                         ]):
 
+    for i, (hsmls, outsize) in enumerate(
+        [
+            (hsmls1, outsize1),
+            (hsmls2, outsize2),
+            (hsmls3, outsize3),
+        ]
+    ):
         masses_rel = []
         for i in range(nrandom):
             data = {
                 "particle_position_x": (np.array([pxs[i]]), "cm"),
                 "particle_position_y": (np.array([pys[i]]), "cm"),
                 "particle_position_z": (np.array([pz]), "cm"),
-                "particle_mass": (np.array([1.]), "g"),
+                "particle_mass": (np.array([1.0]), "g"),
                 "particle_velocity_x": (np.zeros(1), "cm/s"),
                 "particle_velocity_y": (np.zeros(1), "cm/s"),
                 "particle_velocity_z": (np.zeros(1), "cm/s"),
@@ -360,25 +359,28 @@ def test_massconservation_pixave():
 
             proj = ds.proj(("gas", "density"), 2)
             frb = proj.to_frb(
-                width=(3., "cm"),
+                width=(3.0, "cm"),
                 resolution=outsize,
-                height=(3., "cm"),
+                height=(3.0, "cm"),
                 center=np.array([1.5, 1.5, 1.5]),
                 periodic=True,
                 pixelmeaning="pixelave",
             )
             out = frb.get_image(("gas", "density"))
-            mass_in = 1.
+            mass_in = 1.0
             mass_out = np.sum(out.v) * periods**2 / np.prod(outsize)
-            masses_rel.append(mass_out / mass_in - 1.)
+            masses_rel.append(mass_out / mass_in - 1.0)
         masses_rel = np.array(masses_rel)
         minrel = np.min(masses_rel)
         maxrel = np.max(masses_rel)
-        print(f"Mass conservation test pixel/hsml set {i}:"
-              " mass conservation deviations fractions"
-              f" {minrel:.2e} -- {maxrel:.2e} ")
+        print(
+            f"Mass conservation test pixel/hsml set {i}:"
+            " mass conservation deviations fractions"
+            f" {minrel:.2e} -- {maxrel:.2e} "
+        )
         assert np.all(np.abs(masses_rel) < 1e-4)
 
+
 @pytest.mark.parametrize("periodic", [True, False])
 @pytest.mark.parametrize("shiftcenter", [False, True])
 @pytest.mark.parametrize("zoff", [0.0, 0.1, 0.5, 1.0])

yt/testing.py

@@ -158,10 +158,9 @@ def integrate_kernel(
 
 
 def resreduce_image(
-    arr: NDArray[np.float32], 
-    outshape: tuple[int, int]
+    arr: NDArray[np.float32], outshape: tuple[int, int]
 ) -> NDArray[np.float32]:
-    '''
+    """
     gets an image array of size outshape by averaging the pixel values
     in arr over contiguous blocks in each array dimension.
 
@@ -181,19 +180,22 @@ def resreduce_image(
     values in `arr` are averaged over contiguous blocks of size
     (Nsx, Nsy), where Nsx = Nx // outshape[0],
     and Nsy = Ny // outshape[1].
-    '''
+    """
     insize = arr.shape
     if insize[0] % outshape[0] != 0 or insize[1] % outshape[1] != 0:
-        raise ValueError("desired output array shape must use integer"
-                         "divisors of the input array shape. "
-                         f"desired {outshape} doesn't divide "
-                         f"input array shape {arr.shape()}")
+        raise ValueError(
+            "desired output array shape must use integer"
+            "divisors of the input array shape. "
+            f"desired {outshape} doesn't divide "
+            f"input array shape {arr.shape()}"
+        )
     tempi0 = insize[0] // outshape[0]
     tempi1 = insize[1] // outshape[1]
     temp = arr.reshape(outshape[0], tempi0, outshape[1], tempi1)
     out = np.sum(temp, axis=(1, 3)) / (tempi0 * tempi1)
     return out
 
+
 _zeroperiods = np.array([0.0, 0.0, 0.0])
 
 

yt/visualization/tests/test_offaxisprojection_pytestonly.py

@@ -3,7 +3,6 @@
 import unyt
 from numpy.testing import assert_allclose
 
-from yt.data_objects.selection_objects.region import YTRegion
 from yt.testing import (
     assert_rel_equal,
     cubicspline_python,
@@ -174,12 +173,12 @@ def makemasses(i, j, k):
     assert_rel_equal(expected_out, img.v, 4)
 
 
-@pytest.mark.parametrize("axis", [(0., 1e-4, 1.), (0.2, 0., -0.8)])
+@pytest.mark.parametrize("axis", [(0.0, 1e-4, 1.0), (0.2, 0.0, -0.8)])
 @pytest.mark.parametrize("north_vector", [None, (1.0e-4, 1.0, 0.0)])
 @pytest.mark.parametrize("shiftcenter", [True, False])
 @pytest.mark.parametrize("periodic", [True, False])
 @pytest.mark.parametrize("depth", [None, (1.0, "cm"), (5.0, "cm")])
-@pytest.mark.parametrize("hsmlfac", [0.2, 0.5, 1.0]) 
+@pytest.mark.parametrize("hsmlfac", [0.2, 0.5, 1.0])
 def test_sph_proj_pixelave_offaxes(
     axis: tuple[float, float, float],
     north_vector: tuple[float, float, float] | None,
@@ -188,14 +187,13 @@ def test_sph_proj_pixelave_offaxes(
     depth: float,
     hsmlfac: float,
 ) -> None:
-    # weighted and unweighted tested in one round: 
+    # weighted and unweighted tested in one round:
     # need weight map to downsample the baseline weighted map
     if shiftcenter:
         center = unyt.unyt_array(np.array((0.6, 0.5, 0.4)), "cm")
     else:
         center = unyt.unyt_array(np.array((1.5, 1.5, 1.5)), "cm")
-    bbox = unyt.unyt_array(np.array([[0.0, 3.0], [0.0, 3.0], [0.0, 3.0]]),
-                           "cm")
+    bbox = unyt.unyt_array(np.array([[0.0, 3.0], [0.0, 3.0], [0.0, 3.0]]), "cm")
     hsml_factor = hsmlfac
     unitrho = 1.5
     buff_size = (4, 4)
@@ -283,9 +281,8 @@ def makemasses(i, j, k):
     baseimg = resreduce_image(_baseimg, buff_size)
     _baseimg_wtd = baseprj_wtd.frb.data[("gas", "density")]
     _divimg = np.copy(baseimg.v)
-    _divimg[_divimg == 0.] = -1. # avoid div. by 0 test failures
-    baseimg_wtd = (resreduce_image(_baseimg * _baseimg_wtd.v, buff_size) 
-                   / _divimg)
+    _divimg[_divimg == 0.0] = -1.0  # avoid div. by 0 test failures
+    baseimg_wtd = resreduce_image(_baseimg * _baseimg_wtd.v, buff_size) / _divimg
 
     print(
         f"axis: {axis}, shiftcenter: {shiftcenter}, "
@@ -305,7 +302,7 @@ def makemasses(i, j, k):
     # subsampling with multiple particles is not quite at 4.
     # pixel values seem to converge more slowly though, so we test
     # mass conservation explicitly, and pixel agreement at low
-    # precision 
+    # precision
     assert_rel_equal(baseimg.v, testimg.v, 1)
     assert_rel_equal(np.sum(baseimg.v), np.sum(testimg.v), 2)
     assert_rel_equal(baseimg_wtd.v, testimg_wtd.v, 1)