feat: address ruff findings

Author: FredHappyface

documentation/reference/layeredimage/layeredimage.md

@@ -138,7 +138,7 @@ Flatten all layers.
 #### Signature
 
 ```python
-def flattenLayers(self, ignoreHidden: bool = True): ...
+def flattenLayers(self, *, ignoreHidden: bool = True,): ...
 ```
 
 ### LayeredImage().flattenTwoLayers
@@ -151,7 +151,7 @@ Flatten two layers.
 
 ```python
 def flattenTwoLayers(
-    self, background: int, foreground: int, ignoreHidden: bool = True
+    self, background: int, foreground: int, *, ignoreHidden: bool = True,
 ): ...
 ```
 
@@ -164,7 +164,7 @@ Return an image for all flattened layers.
 #### Signature
 
 ```python
-def getFlattenLayers(self, ignoreHidden: bool = True) -> Image.Image: ...
+def getFlattenLayers(self, *, ignoreHidden: bool = True,) -> Image.Image: ...
 ```
 
 ### LayeredImage().getFlattenTwoLayers
@@ -177,7 +177,7 @@ Return an image for two flattened layers.
 
 ```python
 def getFlattenTwoLayers(
-    self, background: int, foreground: int, ignoreHidden: bool = True
+    self, background: int, foreground: int, *, ignoreHidden: bool = True,
 ) -> Image.Image: ...
 ```
 
@@ -304,7 +304,7 @@ Flatten a list of layers and groups.
 def flattenAll(
     layers: list[Layer | Group] | list[Layer],
     imageDimensions: tuple[int, int],
-    ignoreHidden: bool = True,
+    *, ignoreHidden: bool = True,
 ): ...
 ```
 
@@ -338,6 +338,6 @@ def flattenLayerOrGroup(
     layerOrGroup: Layer | Group,
     imageDimensions: tuple[int, int],
     flattenedSoFar: Image.Image | None = None,
-    ignoreHidden: bool = True,
+    *, ignoreHidden: bool = True,
 ): ...
-```
+```

documentation/reference/layeredimage/layergroup.md

@@ -31,7 +31,7 @@ class Group(LayerGroup):
         dimensions: tuple[int, int] | None = None,
         offsets: tuple[int, int] = (0, 0),
         opacity: float = 1.0,
-        visible: bool = True,
+        *, visible: bool = True,
         blendmode: BlendType = BlendType.NORMAL,
     ): ...
 ```
@@ -72,7 +72,7 @@ class Layer(LayerGroup):
         dimensions: tuple[int, int] | None = None,
         offsets: tuple[int, int] = (0, 0),
         opacity: float = 1.0,
-        visible: bool = True,
+        *, visible: bool = True,
         blendmode: BlendType = BlendType.NORMAL,
     ): ...
 ```
@@ -111,7 +111,7 @@ class LayerGroup:
         dimensions: tuple[int, int],
         offsets: tuple[int, int] = (0, 0),
         opacity: float = 1.0,
-        visible: bool = True,
+        *, visible: bool = True,
         blendmode: BlendType = BlendType.NORMAL,
         **kwargs: Any
     ): ...
@@ -151,4 +151,4 @@ Get the object as a dict.
 
 ```python
 def json(self) -> dict[str, Any]: ...
-```
+```

layeredimage/blend.py

@@ -4,4 +4,4 @@
 
 from blendmodes.blend import BlendType, blendLayers
 
-_ = (BlendType, blendLayers )
+_ = (BlendType, blendLayers)

layeredimage/io/gif.py

@@ -19,9 +19,9 @@ def openLayer_GIF(file: str) -> LayeredImage:
 		project.seek(index)
 		layers.append(
 			Layer(
-				f"Frame {len(layers) + 1} ({project.info['duration']}ms)",
-				project.copy(),
-				projectSize,
+				name=f"Frame {len(layers) + 1} ({project.info['duration']}ms)",
+				image=project.copy(),
+				dimensions=projectSize,
 			)
 		)
 	project.close()

layeredimage/io/layered.py

@@ -67,30 +67,30 @@ def openLayer_LAYERED(file: str) -> LayeredImage:
 				]
 				layersAndGroups.append(
 					Group(
-						layerOrGroup["name"],
-						layers,
-						layerOrGroup["dimensions"],
-						layerOrGroup["offsets"],
-						layerOrGroup["opacity"],
-						layerOrGroup["visible"],
-						blendModeLookup(layerOrGroup["blendmode"], blendLookup),
+						name=layerOrGroup["name"],
+						layers=layers,
+						dimensions=layerOrGroup["dimensions"],
+						offsets=layerOrGroup["offsets"],
+						opacity=layerOrGroup["opacity"],
+						visible=layerOrGroup["visible"],
+						blendmode=blendModeLookup(layerOrGroup["blendmode"], blendLookup),
 					)
 				)
 		return LayeredImage(layersAndGroups, stack["dimensions"])
 
 
 def grabLayer_LAYERED(zipFile: ZipFile, layer: dict[str, Any], blendLookup: dict[str, Any]):
 	"""Grab an image from .layered."""
-	with zipFile.open("data/" + layer["name"] + ".png") as layerImage:
+	with zipFile.open(f'data/{layer["name"]}.png') as layerImage:
 		image = Image.open(layerImage).convert("RGBA")
 	return Layer(
-		layer["name"],
-		image,
-		layer["dimensions"],
-		layer["offsets"],
-		layer["opacity"],
-		layer["visible"],
-		blendModeLookup(layer["blendmode"], blendLookup),
+		name=layer["name"],
+		image=image,
+		dimensions=layer["dimensions"],
+		offsets=layer["offsets"],
+		opacity=layer["opacity"],
+		visible=layer["visible"],
+		blendmode=blendModeLookup(layer["blendmode"], blendLookup),
 	)
 
 
@@ -117,7 +117,9 @@ def _saveLayer_LAYERED(fileName: str, layeredImage: LayeredImage, compressed: bo
 			writeImage_LAYERED(imageData, layered, imageName + ".png", compressed)
 
 
-def writeImage_LAYERED(image: Image.Image, zipFile: ZipFile, path: str, compressed: bool = False) -> None:
+def writeImage_LAYERED(
+	image: Image.Image, zipFile: ZipFile, path: str, compressed: bool = False
+) -> None:
 	"""Write an image to the archive."""
 	imgByteArr = io.BytesIO()
 	imageCopy = image.copy()

layeredimage/io/lsr.py

@@ -19,13 +19,17 @@ def openLayer_LSR(file: str) -> LayeredImage:
 	for group in project.layers:
 		groups.append(
 			Group(
-				group.name,
-				[
-					Layer(layer.name, layer.scaledImage(), layer.scaledImage().size)
+				name=group.name,
+				layers=[
+					Layer(
+						name=layer.name,
+						image=layer.scaledImage(),
+						dimensions=layer.scaledImage().size,
+					)
 					for layer in group.images
 				],
-				group.size,
-				(int(group.offsets()[0]), int(group.offsets()[1])),
+				dimensions=group.size,
+				offsets=(int(group.offsets()[0]), int(group.offsets()[1])),
 			)
 		)
 	return LayeredImage(groups, project.size)

layeredimage/io/ora.py

@@ -42,38 +42,38 @@ def openLayer_ORA(file: str) -> LayeredImage:
 		if layerOrGroup.type == TYPE_LAYER:
 			layersAndGroups.append(
 				Layer(
-					layerOrGroup.name,
-					layerOrGroup.get_image_data(True),
-					layerOrGroup.dimensions,
-					layerOrGroup.offsets,
-					layerOrGroup.opacity,
-					layerOrGroup.visible,
-					blendModeLookup(layerOrGroup.composite_op, blendLookup),
+					name=layerOrGroup.name,
+					image=layerOrGroup.get_image_data(True),
+					dimensions=layerOrGroup.dimensions,
+					offsets=layerOrGroup.offsets,
+					opacity=layerOrGroup.opacity,
+					visible=layerOrGroup.visible,
+					blendmode=blendModeLookup(layerOrGroup.composite_op, blendLookup),
 				)
 			)
 		else:
 			layers = []
 			for layer in list(layerOrGroup.children)[::-1]:
 				layers.append(
 					Layer(
-						layer.name,
-						layer.get_image_data(True),
-						layer.dimensions,
-						layer.offsets,
-						layer.opacity,
-						layer.visible,
-						blendModeLookup(layerOrGroup.composite_op, blendLookup),
+						name=layer.name,
+						image=layer.get_image_data(True),
+						dimensions=layer.dimensions,
+						offsets=layer.offsets,
+						opacity=layer.opacity,
+						visible=layer.visible,
+						blendmode=blendModeLookup(layerOrGroup.composite_op, blendLookup),
 					)
 				)
 			layersAndGroups.append(
 				Group(
-					layerOrGroup.name,
-					layers,
-					project.dimensions,
-					layerOrGroup.offsets,
-					layerOrGroup.opacity,
-					layerOrGroup.visible,
-					blendModeLookup(layerOrGroup.composite_op, blendLookup),
+					name=layerOrGroup.name,
+					layers=layers,
+					dimensions=project.dimensions,
+					offsets=layerOrGroup.offsets,
+					opacity=layerOrGroup.opacity,
+					visible=layerOrGroup.visible,
+					blendmode=blendModeLookup(layerOrGroup.composite_op, blendLookup),
 				)
 			)
 	return LayeredImage(layersAndGroups, project.dimensions)

layeredimage/io/pdn.py

@@ -38,13 +38,13 @@ def openLayer_PDN(file: str) -> LayeredImage:
 		image = Image.fromarray(layer.image)
 		layers.append(
 			Layer(
-				layer.name,
-				image,
-				image.size,
-				(0, 0),
-				layer.opacity / 255,
-				layer.visible,
-				blendModeLookup(layer.blendMode, blendLookup),
+				name=layer.name,
+				image=image,
+				dimensions=image.size,
+				offsets=(0, 0),
+				opacity=layer.opacity / 255,
+				visible=layer.visible,
+				blendmode=blendModeLookup(layer.blendMode, blendLookup),
 			)
 		)
 	return LayeredImage(layers, (project.width, project.height))

layeredimage/io/psd.py

@@ -44,36 +44,36 @@ def openLayer_PSD(file: str) -> LayeredImage:
 			for layer in layerOrGroup:
 				layers.append(
 					Layer(
-						layer.name,
-						layer.topil(),
-						(layer.width, layer.height),
-						(layer.left - layerOrGroup.left, layer.top - layerOrGroup.top),
-						layer.opacity / 255,
-						layer.visible,
-						blendModeLookup(layer.blend_mode, blendLookup),
+						name=layer.name,
+						image=layer.topil(),
+						dimensions=(layer.width, layer.height),
+						offsets=(layer.left - layerOrGroup.left, layer.top - layerOrGroup.top),
+						opacity=layer.opacity / 255,
+						visible=layer.visible,
+						blendmode=blendModeLookup(layer.blend_mode, blendLookup),
 					)
 				)
 			layersAndGroups.append(
 				Group(
-					layerOrGroup.name,
-					layers,
-					(layerOrGroup.width, layerOrGroup.height),
-					(layerOrGroup.left, layerOrGroup.top),
-					layerOrGroup.opacity / 255,
-					layerOrGroup.visible,
-					blendModeLookup(layerOrGroup.blend_mode, blendLookup),
+					name=layerOrGroup.name,
+					layers=layers,
+					dimensions=(layerOrGroup.width, layerOrGroup.height),
+					offsets=(layerOrGroup.left, layerOrGroup.top),
+					opacity=layerOrGroup.opacity / 255,
+					visible=layerOrGroup.visible,
+					blendmode=blendModeLookup(layerOrGroup.blend_mode, blendLookup),
 				)
 			)
 		else:
 			layersAndGroups.append(
 				Layer(
-					layerOrGroup.name,
-					layerOrGroup.topil(),
-					(layerOrGroup.width, layerOrGroup.height),
-					(layerOrGroup.left, layerOrGroup.top),
-					layerOrGroup.opacity / 255,
-					layerOrGroup.visible,
-					blendModeLookup(layerOrGroup.blend_mode, blendLookup),
+					name=layerOrGroup.name,
+					image=layerOrGroup.topil(),
+					dimensions=(layerOrGroup.width, layerOrGroup.height),
+					offsets=(layerOrGroup.left, layerOrGroup.top),
+					opacity=layerOrGroup.opacity / 255,
+					visible=layerOrGroup.visible,
+					blendmode=blendModeLookup(layerOrGroup.blend_mode, blendLookup),
 				)
 			)
 	return LayeredImage(layersAndGroups, (project.width, project.height))

layeredimage/io/tiff.py

@@ -37,12 +37,12 @@ def openLayer_TIFF(file: str) -> LayeredImage:
 		# Add the layer
 		layers.append(
 			Layer(
-				ifd["PageName"][0],
-				project.copy(),
-				(ifd["ImageWidth"][0], ifd["ImageLength"][0]),
-				(offsetX, offsetY),
-				1,
-				True,
+				name=ifd["PageName"][0],
+				image=project.copy(),
+				dimensions=(ifd["ImageWidth"][0], ifd["ImageLength"][0]),
+				offsets=(offsetX, offsetY),
+				opacity=1,
+				visible=True,
 			)
 		)
 	project.close()