Fix Ruff lints

Signed-off-by: Benjamin Gilbert <bgilbert@cs.cmu.edu>

Author: bgilbert

examples/deepzoom/deepzoom_multiserver.py

@@ -192,7 +192,7 @@ def tile(path: str, level: int, col: int, row: int, format: str) -> Response:
             icc_profile=tile.info.get('icc_profile'),
         )
         resp = make_response(buf.getvalue())
-        resp.mimetype = 'image/%s' % format
+        resp.mimetype = f'image/{format}'
         return resp
 
     return app

examples/deepzoom/deepzoom_server.py

@@ -193,7 +193,7 @@ def tile(slug: str, level: int, col: int, row: int, format: str) -> Response:
             icc_profile=tile.info.get('icc_profile'),
         )
         resp = make_response(buf.getvalue())
-        resp.mimetype = 'image/%s' % format
+        resp.mimetype = f'image/{format}'
         return resp
 
     return app

examples/deepzoom/deepzoom_tile.py

@@ -231,8 +231,7 @@ def _tile_done(self) -> None:
         count, total = self._processed, self._dz.tile_count
         if count % 100 == 0 or count == total:
             print(
-                'Tiling %s: wrote %d/%d tiles'
-                % (self._associated or 'slide', count, total),
+                f'Tiling {self._associated or "slide"}: wrote {count}/{total} tiles',
                 end='\r',
                 file=sys.stderr,
             )
@@ -320,7 +319,7 @@ def _url_for(self, associated: str | None) -> str:
             base = VIEWER_SLIDE_NAME
         else:
             base = self._slugify(associated)
-        return '%s.dzi' % base
+        return f'{base}.dzi'
 
     def _write_html(self) -> None:
         import jinja2

openslide/__init__.py

@@ -169,7 +169,9 @@ def get_thumbnail(self, size: tuple[int, int]) -> Image.Image:
         """Return a PIL.Image containing an RGB thumbnail of the image.
 
         size:     the maximum size of the thumbnail."""
-        downsample = max(dim / thumb for dim, thumb in zip(self.dimensions, size))
+        downsample = max(
+            dim / thumb for dim, thumb in zip(self.dimensions, size, strict=True)
+        )
         level = self.get_best_level_for_downsample(downsample)
         tile = self.read_region((0, 0), level, self.level_dimensions[level])
         # Apply on solid background
@@ -460,20 +462,25 @@ def read_region(
         # the image.  Create a transparent tile of the correct size and
         # paste the valid part of the region into the correct location.
         image_topleft = [
-            max(0, min(l, limit - 1)) for l, limit in zip(location, self._image.size)
+            max(0, min(l, limit - 1))
+            for l, limit in zip(location, self._image.size, strict=True)
         ]
         image_bottomright = [
             max(0, min(l + s - 1, limit - 1))
-            for l, s, limit in zip(location, size, self._image.size)
+            for l, s, limit in zip(location, size, self._image.size, strict=True)
         ]
         tile = Image.new('RGBA', size, (0,) * 4)
         if not [
-            'fail' for tl, br in zip(image_topleft, image_bottomright) if br - tl < 0
+            'fail'
+            for tl, br in zip(image_topleft, image_bottomright, strict=True)
+            if br - tl < 0
         ]:  # "< 0" not a typo
             # Crop size is greater than zero in both dimensions.
             # PIL thinks the bottom right is the first *excluded* pixel
             crop_box = tuple(image_topleft + [d + 1 for d in image_bottomright])
-            tile_offset = tuple(il - l for il, l in zip(image_topleft, location))
+            tile_offset = tuple(
+                il - l for il, l in zip(image_topleft, location, strict=True)
+            )
             assert len(crop_box) == 4 and len(tile_offset) == 2
             crop = self._image.crop(crop_box)
             tile.paste(crop, tile_offset)

openslide/deepzoom.py

@@ -88,13 +88,15 @@ def __init__(
             # Slide level dimensions scale factor in each axis
             size_scale = tuple(
                 int(osr.properties.get(prop, l0_lim)) / l0_lim
-                for prop, l0_lim in zip(self.BOUNDS_SIZE_PROPS, osr.dimensions)
+                for prop, l0_lim in zip(
+                    self.BOUNDS_SIZE_PROPS, osr.dimensions, strict=True
+                )
             )
             # Dimensions of active area
             self._l_dimensions = tuple(
                 tuple(
-                    int(math.ceil(l_lim * scale))
-                    for l_lim, scale in zip(l_size, size_scale)
+                    math.ceil(l_lim * scale)
+                    for l_lim, scale in zip(l_size, size_scale, strict=True)
                 )
                 for l_size in osr.level_dimensions
             )
@@ -106,14 +108,14 @@ def __init__(
         z_size = self._l0_dimensions
         z_dimensions = [z_size]
         while z_size[0] > 1 or z_size[1] > 1:
-            z_size = tuple(max(1, int(math.ceil(z / 2))) for z in z_size)
+            z_size = tuple(max(1, math.ceil(z / 2)) for z in z_size)
             z_dimensions.append(z_size)
         # Narrow the type, for self.level_dimensions
         self._z_dimensions = self._pairs_from_n_tuples(tuple(reversed(z_dimensions)))
 
         # Tile
         def tiles(z_lim: int) -> int:
-            return int(math.ceil(z_lim / self._z_t_downsample))
+            return math.ceil(z_lim / self._z_t_downsample)
 
         self._t_dimensions = tuple(
             (tiles(z_w), tiles(z_h)) for z_w, z_h in self._z_dimensions
@@ -203,7 +205,7 @@ def _get_tile_info(
         # Check parameters
         if dz_level < 0 or dz_level >= self._dz_levels:
             raise ValueError('Invalid level')
-        for t, t_lim in zip(t_location, self._t_dimensions[dz_level]):
+        for t, t_lim in zip(t_location, self._t_dimensions[dz_level], strict=True):
             if t < 0 or t >= t_lim:
                 raise ValueError('Invalid address')
 
@@ -214,31 +216,37 @@ def _get_tile_info(
         z_overlap_tl = tuple(self._z_overlap * int(t != 0) for t in t_location)
         z_overlap_br = tuple(
             self._z_overlap * int(t != t_lim - 1)
-            for t, t_lim in zip(t_location, self.level_tiles[dz_level])
+            for t, t_lim in zip(t_location, self.level_tiles[dz_level], strict=True)
         )
 
         # Get final size of the tile
         z_size = tuple(
             min(self._z_t_downsample, z_lim - self._z_t_downsample * t) + z_tl + z_br
             for t, z_lim, z_tl, z_br in zip(
-                t_location, self._z_dimensions[dz_level], z_overlap_tl, z_overlap_br
+                t_location,
+                self._z_dimensions[dz_level],
+                z_overlap_tl,
+                z_overlap_br,
+                strict=True,
             )
         )
 
         # Obtain the region coordinates
         z_location = [self._z_from_t(t) for t in t_location]
         l_location = [
             self._l_from_z(dz_level, z - z_tl)
-            for z, z_tl in zip(z_location, z_overlap_tl)
+            for z, z_tl in zip(z_location, z_overlap_tl, strict=True)
         ]
         # Round location down and size up, and add offset of active area
         l0_location = tuple(
             int(self._l0_from_l(slide_level, l) + l0_off)
-            for l, l0_off in zip(l_location, self._l0_offset)
+            for l, l0_off in zip(l_location, self._l0_offset, strict=True)
         )
         l_size = tuple(
             int(min(math.ceil(self._l_from_z(dz_level, dz)), l_lim - math.ceil(l)))
-            for l, dz, l_lim in zip(l_location, z_size, self._l_dimensions[slide_level])
+            for l, dz, l_lim in zip(
+                l_location, z_size, self._l_dimensions[slide_level], strict=True
+            )
         )
 
         # Return read_region() parameters plus tile size for final scaling

openslide/lowlevel.py

@@ -379,7 +379,7 @@ def decorator(fn: Callable[_P, _T]) -> _Func[_P, _T]:
         'openslide_detect_vendor', c_char_p, [_filename_p], _check_string
     )
 except AttributeError:
-    raise OpenSlideVersionError('3.4.0')
+    raise OpenSlideVersionError('3.4.0') from None
 
 open: _Func[[Filename], _OpenSlide] = _func(
     'openslide_open', c_void_p, [_filename_p], _check_open
@@ -434,7 +434,7 @@ def read_region(
         # OpenSlide would catch this, but not before we tried to allocate
         # a negative-size buffer
         raise OpenSlideError(
-            'negative width (%d) or negative height (%d) not allowed' % (w, h)
+            f'negative width ({w}) or negative height ({h}) not allowed'
         )
     if w == 0 or h == 0:
         # Image.frombuffer() would raise an exception

tests/test_deepzoom.py

@@ -44,8 +44,7 @@ def tearDown(self) -> None:
         def test_repr(self) -> None:
             self.assertEqual(
                 repr(self.dz),
-                'DeepZoomGenerator(%r, tile_size=254, overlap=1, limit_bounds=False)'
-                % self.osr,
+                f'DeepZoomGenerator({self.osr!r}, tile_size=254, overlap=1, limit_bounds=False)',
             )
 
         def test_metadata(self) -> None:

tests/test_imageslide.py

@@ -42,7 +42,7 @@ def test_open_image(self) -> None:
         with Image.open(file_path('boxes.png')) as img:
             with ImageSlide(img) as osr:
                 self.assertEqual(osr.dimensions, (300, 250))
-                self.assertEqual(repr(osr), 'ImageSlide(%r)' % img)
+                self.assertEqual(repr(osr), f'ImageSlide({img!r})')
 
     @unittest.skipUnless(
         sys.getfilesystemencoding() == 'utf-8',
@@ -96,7 +96,7 @@ class TestImage(_Abstract.SlideTest):
     FILENAME = 'boxes.png'
 
     def test_repr(self) -> None:
-        self.assertEqual(repr(self.osr), 'ImageSlide(%r)' % file_path('boxes.png'))
+        self.assertEqual(repr(self.osr), f'ImageSlide({file_path("boxes.png")!r})')
 
     def test_metadata(self) -> None:
         self.assertEqual(self.osr.level_count, 1)

tests/test_openslide.py

@@ -124,7 +124,7 @@ class TestSlide(_Abstract.SlideTest):
     FILENAME = 'boxes.tiff'
 
     def test_repr(self) -> None:
-        self.assertEqual(repr(self.osr), 'OpenSlide(%r)' % file_path('boxes.tiff'))
+        self.assertEqual(repr(self.osr), f'OpenSlide({file_path("boxes.tiff")!r})')
 
     def test_basic_metadata(self) -> None:
         self.assertEqual(self.osr.level_count, 4)
@@ -146,11 +146,9 @@ def test_properties(self) -> None:
         self.assertEqual(self.osr.properties['openslide.vendor'], 'generic-tiff')
         self.assertRaises(KeyError, lambda: self.osr.properties['__does_not_exist'])
         # test __len__ and __iter__
+        self.assertEqual(len(list(self.osr.properties)), len(self.osr.properties))
         self.assertEqual(
-            len([v for v in self.osr.properties]), len(self.osr.properties)
-        )
-        self.assertEqual(
-            repr(self.osr.properties), '<_PropertyMap %r>' % dict(self.osr.properties)
+            repr(self.osr.properties), f'<_PropertyMap {dict(self.osr.properties)!r}>'
         )
 
     @unittest.skipUnless(
@@ -215,7 +213,7 @@ def test_associated_images(self) -> None:
         self.assertRaises(KeyError, lambda: self.osr.associated_images['__missing'])
         # test __len__ and __iter__
         self.assertEqual(
-            len([v for v in self.osr.associated_images]),
+            len(list(self.osr.associated_images)),
             len(self.osr.associated_images),
         )
 
@@ -224,7 +222,7 @@ def mangle_repr(o: Any) -> str:
 
         self.assertEqual(
             mangle_repr(self.osr.associated_images),
-            '<_AssociatedImageMap %s>' % mangle_repr(dict(self.osr.associated_images)),
+            f'<_AssociatedImageMap {mangle_repr(dict(self.osr.associated_images))}>',
         )
 
     def test_color_profile(self) -> None: