Bump pylinalg & ruff format (#931)

* Bump pylinalg

* ruff format

Author: Korijn

examples/other/hirez_screenshot.py

@@ -259,7 +259,7 @@ def animate():
 print("full resolution:", full_im.shape)
 filename = os.path.join(tempfile.gettempdir(), "hirez_pygfx.png")
 iio.imwrite(filename, full_im)
-print(f"{os.stat(filename).st_size/2**20:0.3f} MiB")
+print(f"{os.stat(filename).st_size / 2**20:0.3f} MiB")
 
 # Show the image
 webbrowser.open("file://" + filename)

examples/other/integration_pytorch.py

@@ -720,7 +720,7 @@ def _on_batch_end(
         self._queue.put(obj=mesh_data)
 
         # print current loss
-        print(f'Loss: {outputs["loss"]}')
+        print(f"Loss: {outputs['loss']}")
 
     def on_train_batch_end(self, *args, **kwargs) -> None:
         self._on_batch_end(*args)

pygfx/helpers/_box.py

@@ -131,8 +131,7 @@ def set_transform_by_object(self, object: WorldObject, space="world", scale=1.0)
         aabb = None
         if space not in {"world", "local"}:
             raise ValueError(
-                'Space argument must be either "world"'
-                f'or "local". Given value: {space}'
+                f'Space argument must be either "world"or "local". Given value: {space}'
             )
         if space == "world":
             aabb = object.get_world_bounding_box()

pygfx/renderers/wgpu/engine/pipeline.py

@@ -88,7 +88,7 @@ def get_cached_shader_module(device, shader, shader_kwargs):
             # PYGFX_PRINT_WGSL_ON_COMPILATION_ERROR
             if PRINT_WGSL_ON_ERROR:
                 wgsl_with_line_numbers = "\n".join(
-                    f"{i+1:5d}: {line}" for i, line in enumerate(wgsl.splitlines())
+                    f"{i + 1:5d}: {line}" for i, line in enumerate(wgsl.splitlines())
                 )
                 print(wgsl_with_line_numbers, file=sys.stderr)
             raise

pygfx/renderers/wgpu/engine/renderer.py

@@ -578,7 +578,7 @@ def flush(self, target=None):
         now = time.perf_counter()
         if self._show_fps:
             if self._fps["count"] == 0:
-                print(f"Time to first draw: {now-self._fps['start']:0.2f}")
+                print(f"Time to first draw: {now - self._fps['start']:0.2f}")
                 self._fps["start"] = now
                 self._fps["count"] = 1
             elif now > self._fps["start"] + 1:

pygfx/renderers/wgpu/shader/bindings.py

@@ -66,19 +66,19 @@ def _define_uniform(self, bindgroup, index, binding):
             structname = self._uniform_struct_names[struct_hash]
             if binding.structname is not None:
                 # Do we need to ensure that a dtype corresponds to only one struct?
-                assert (
-                    structname == binding.structname
-                ), "dtype[{struct_hash}] has been defined as struct[{structname}]"
+                assert structname == binding.structname, (
+                    "dtype[{struct_hash}] has been defined as struct[{structname}]"
+                )
         except KeyError:
             # sometimes, we need a meaningful alias for the struct name.
             if binding.structname is not None:
                 structname = binding.structname
-                assert (
-                    structname not in self._uniform_struct_names.values()
-                ), "structname has been used for another dtype"
+                assert structname not in self._uniform_struct_names.values(), (
+                    "structname has been used for another dtype"
+                )
             else:
                 # auto generate struct name
-                structname = f"Struct_u_{len(self._uniform_struct_names)+1}"
+                structname = f"Struct_u_{len(self._uniform_struct_names) + 1}"
 
             self._uniform_struct_names[struct_hash] = structname
 

pygfx/renderers/wgpu/shaders/meshshader.py

@@ -385,27 +385,27 @@ def _encode_morph_texture(self, geometry):
         for i in range(morph_count):
             if morph_positions:
                 morph_position = morph_positions[i]
-                assert (
-                    len(morph_position) == vertice_count
-                ), f"Morph target {i} has {len(morph_position)} vertices, expected {vertice_count}"
+                assert len(morph_position) == vertice_count, (
+                    f"Morph target {i} has {len(morph_position)} vertices, expected {vertice_count}"
+                )
                 morph_position = np.pad(morph_position, ((0, 0), (0, 1)), "constant")
             else:
                 morph_position = np.zeros((vertice_count, 4), dtype=np.float32)
 
             if morph_normals:
                 morph_normal = morph_normals[i]
-                assert (
-                    len(morph_normal) == vertice_count
-                ), f"Morph normal {i} has {len(morph_normal)} vertices, expected {vertice_count}"
+                assert len(morph_normal) == vertice_count, (
+                    f"Morph normal {i} has {len(morph_normal)} vertices, expected {vertice_count}"
+                )
                 morph_normal = np.pad(morph_normal, ((0, 0), (0, 1)), "constant")
             else:
                 morph_normal = np.zeros((vertice_count, 4), dtype=np.float32)
 
             if morph_colors:
                 morph_color = morph_colors[i]
-                assert (
-                    len(morph_color) == vertice_count
-                ), f"Morph color {i} has {len(morph_colors[i])} vertices, expected {vertice_count}"
+                assert len(morph_color) == vertice_count, (
+                    f"Morph color {i} has {len(morph_colors[i])} vertices, expected {vertice_count}"
+                )
             else:
                 morph_color = np.zeros((vertice_count, 4), dtype=np.float32)
 
@@ -487,22 +487,22 @@ def _check_texture(self, t, geometry, view_dim):
             texcoords = getattr(geometry, f"texcoords{uv_channel}", None)
         else:
             texcoords = getattr(geometry, "texcoords", None)
-        assert (
-            texcoords is not None
-        ), f"Texture {t} requires geometry.texcoords{uv_channel or ''}"
+        assert texcoords is not None, (
+            f"Texture {t} requires geometry.texcoords{uv_channel or ''}"
+        )
 
         if view_dim == "1d":
-            assert (
-                texcoords.data.ndim == 1 or texcoords.data.shape[-1] == 1
-            ), f"Texture {t} requires 1D texcoords"
+            assert texcoords.data.ndim == 1 or texcoords.data.shape[-1] == 1, (
+                f"Texture {t} requires 1D texcoords"
+            )
         elif view_dim == "2d" or view_dim == "2d-array":
-            assert (
-                texcoords.data.ndim == 2 and texcoords.data.shape[-1] == 2
-            ), f"Texture {t} requires 2D texcoords"
+            assert texcoords.data.ndim == 2 and texcoords.data.shape[-1] == 2, (
+                f"Texture {t} requires 2D texcoords"
+            )
         elif view_dim == "cube" or view_dim == "3d" or view_dim == "cube-array":
-            assert (
-                texcoords.data.ndim == 2 and texcoords.data.shape[-1] == 3
-            ), f"Texture {t} requires 3D texcoords"
+            assert texcoords.data.ndim == 2 and texcoords.data.shape[-1] == 3, (
+                f"Texture {t} requires 3D texcoords"
+            )
         else:
             raise ValueError(f"Unknown view_dim: {view_dim}")
 

pygfx/utils/color.py

@@ -301,9 +301,11 @@ def css(self):
         """The CSS color string, e.g. "rgba(0,255,0,0.5)"."""
         r, g, b, a = self.rgba
         if a == 1:
-            return f"rgb({int(255*r+0.5)},{int(255*g+0.5)},{int(255*b+0.5)})"
+            return (
+                f"rgb({int(255 * r + 0.5)},{int(255 * g + 0.5)},{int(255 * b + 0.5)})"
+            )
         else:
-            return f"rgba({int(255*r+0.5)},{int(255*g+0.5)},{int(255*b+0.5)},{a:0.3f})"
+            return f"rgba({int(255 * r + 0.5)},{int(255 * g + 0.5)},{int(255 * b + 0.5)},{a:0.3f})"
 
     def clip(self):
         """Return a new Color with the values clipped between 0 and 1."""

pyproject.toml

@@ -20,7 +20,7 @@ requires-python = ">= 3.9"
 dependencies = [
     "rendercanvas >= 2",
     "wgpu >=0.19.0,<0.20.0",
-    "pylinalg >=0.6.2,<0.7.0",
+    "pylinalg >=0.6.3,<0.7.0",
     "numpy",
     "freetype-py",
     "uharfbuzz",

tests/geometries/test_text_geometry.py

@@ -340,7 +340,7 @@ def test_check_speed():
     dt = time.perf_counter() - t0
     print(
         f"\ngenerate_glyph: {n_iter * dt:0.1f} ms total",
-        f"{1E6 * dt / (n_iter * n_glyphs):0.2f} us per glyph",
+        f"{1e6 * dt / (n_iter * n_glyphs):0.2f} us per glyph",
     )
 
 

tests/objects/test_events.py

@@ -248,9 +248,9 @@ def test_pointer_event_copy():
         if not attr.startswith("_") and not callable(getattr(other, attr))
     ]:
         if attr not in ["type", "clicks"]:
-            assert getattr(other, attr) == getattr(
-                event, attr
-            ), f"'{attr}' attribute not equal"
+            assert getattr(other, attr) == getattr(event, attr), (
+                f"'{attr}' attribute not equal"
+            )
 
     assert other.type != event.type
     assert other.type == "click"

tests/objects/test_materials.py

@@ -22,9 +22,9 @@ def test_uniform_types_uniform_type():
             else:
                 for key, val in super_cls.uniform_type.items():
                     assert key in ob.uniform_type, f"{cls.__name__}:{key} missing"
-                    assert (
-                        val == ob.uniform_type[key]
-                    ), f"{cls.__name__}:{key} different"
+                    assert val == ob.uniform_type[key], (
+                        f"{cls.__name__}:{key} different"
+                    )
 
 
 if __name__ == "__main__":

tests/renderers/test_environment.py

@@ -58,9 +58,9 @@ def test_environment_reuse2():
 
     assert env1 is not env2, "env1 and env2 have different number of lights"
     assert env2 is env3, "env2 and env3 have same number of lights"
-    assert (
-        env2 is env4
-    ), "env2 and env4 have same number of lights, ambient lights dont count"
+    assert env2 is env4, (
+        "env2 and env4 have same number of lights, ambient lights dont count"
+    )
     assert env2 is not env5, "env2 and env5 have different number of lights"
 
 

tests/utils/test_text_fontmanager.py

@@ -316,7 +316,8 @@ def check_speed():
         font_manager.select_font(text, FontProps())
     dt = time.perf_counter() - t0
     print(
-        f"select_font: {1000*dt:0.1f} ms total", f"{1000*dt/(10000):0.3f} ms per char"
+        f"select_font: {1000 * dt:0.1f} ms total",
+        f"{1000 * dt / (10000):0.3f} ms per char",
     )
 
     # About 0.00 ms (0.3 us), so this  negligible.

tests/utils/test_text_sdf.py

@@ -54,8 +54,8 @@ def check_speed():
         generate_glyph(indices, font.filename)
     dt = time.perf_counter() - t0
     print(
-        f"generate_glyph: {1000*dt:0.1f} ms total",
-        f"{1000*dt/(10000):0.3f} ms per glyph",
+        f"generate_glyph: {1000 * dt:0.1f} ms total",
+        f"{1000 * dt / (10000):0.3f} ms per glyph",
     )
 
     # If I tweak generate_glyph() to include the time in the hash,

tests/utils/test_text_shaping.py

@@ -217,17 +217,17 @@ def check_speed():
         shape_text_hb(text, font.filename)
     dt = time.perf_counter() - t0
     print(
-        f"shape_text_hb: {1000*dt:0.1f} ms total",
-        f"{1000*dt/(10000):0.3f} ms per glyph",
+        f"shape_text_hb: {1000 * dt:0.1f} ms total",
+        f"{1000 * dt / (10000):0.3f} ms per glyph",
     )
 
     t0 = time.perf_counter()
     for _i in range(1000):
         shape_text_ft(text, font.filename)
     dt = time.perf_counter() - t0
     print(
-        f"shape_text_ft: {1000*dt:0.1f} ms total",
-        f"{1000*dt/(10000):0.3f} ms per glyph",
+        f"shape_text_ft: {1000 * dt:0.1f} ms total",
+        f"{1000 * dt / (10000):0.3f} ms per glyph",
     )
 
     # No cache:    about 0.03  and 0.02  ms per glyph for Harfbuzz and FreeType, respectively.