stewbeet 2.0.22__tar.gz → 2.0.24__tar.gz

{stewbeet-2.0.22 → stewbeet-2.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.0.22
+Version: 2.0.24
 Summary: Beet Framework made to help generating advanced Minecraft datapack contents
 Project-URL: Homepage, https://github.com/Stoupy51/stewbeet
 Project-URL: Issues, https://github.com/Stoupy51/stewbeet/issues

{stewbeet-2.0.22 → stewbeet-2.0.24}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "stewbeet"
-version = "2.0.22"
+version = "2.0.24"
 description = "Beet Framework made to help generating advanced Minecraft datapack contents"
 readme = "README.md"
 license = "MIT"

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/contrib/simplenergy/balancing.py

@@ -90,5 +90,5 @@ execute if score @s energy.storage > @s energy.max_storage run scoreboard player
 
 	# Add in the placement function the balancing tag
 	for device in can_balance:
-		write_function(f"{ns}:custom_blocks/{device}/place_secondary", f"\n# Add balancing tag\ntag @s add {can_balance_tag}")
+		write_function(f"{ns}:custom_blocks/{device}/place_secondary", f"\n# Add balancing tag\ntag @s add {can_balance_tag}\n")
 

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/contrib/simplenergy/cables.py

@@ -42,7 +42,7 @@ def setup_cables_models(cables: list[str]) -> None:
 					# Create the new json
 					new_json: dict = {
 						"parent": f"{ns}:block/cable_base",
-						"textures": {"0": f"{ns}:block/{cable}"}
+						"textures": {"0": f"{ns}:block/{cable}", "particle": f"{ns}:block/{cable}"},
 					}
 					new_json.update(json_file)
 

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/contrib/simplenergy/gui.py

@@ -62,7 +62,7 @@ def setup_gui_in_resource_packs(gui_translations: dict[str, GuiTranslation]) ->
 	}
 	for gui, model in gui_models.items():
 		content: dict = json.loads(json.dumps(base))  # Deep copy the base model
-		content["textures"]["layer0"] = model.replace(":", ":item/")
+		content["textures"]["layer0"] = content["textures"]["particle"] = model.replace(":", ":item/")
 
 		# If any translation is provided, add it to the model
 		for item, translation in gui_translations.items():

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/core/definitions_helper/completion.py

@@ -50,7 +50,7 @@ def add_item_name_and_lore_if_missing(is_external: bool = False, black_list: lis
 				item_str: str = item.replace("_"," ").title()
 			else:
 				item_str: str = item.split(":")[-1].replace("_"," ").title()
-			data["item_name"] = item_str
+			data["item_name"] = {"text": item_str}	# Use a TextComponent to allow auto.lang_file to work properly
 
 		# Apply namespaced lore if none
 		if not data.get("lore"):

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/core/utils/io.py

@@ -2,7 +2,7 @@
 # Imports
 from typing import Any
 
-from beet import Function, FunctionTag, JsonFile
+from beet import Function, JsonFile, NamespaceContainer, NamespaceProxy, TagFile
 from beet.core.utils import JsonDict
 from stouputils.collections import unique_list
 from stouputils.io import super_json_dump
@@ -11,28 +11,39 @@ from ..__memory__ import Mem
 
 
 # Functions
-def write_function_tag(path: str, functions: list[Any] | None = None, prepend: bool = False) -> None:
+def write_tag(path: str, tag_type: NamespaceProxy[TagFile] | NamespaceContainer[TagFile], values: list[Any] | None = None, prepend: bool = False) -> None:
 	""" Write a function tag at the given path.
 
 	Args:
 		path        (str):  The path to the function tag (ex: "namespace:something" for 'data/namespace/tags/function/something.json')
-		functions   (list[Any] | None): The functions to add to the tag
-		prepend     (bool): If the functions should be prepended instead of appended
+		tag_type    (NamespaceProxy[TagFile]): The tag type to write to (ex: ctx.data.function_tags)
+		values      (list[Any] | None): The values to add to the tag
+		prepend     (bool): If the values should be prepended instead of appended
 	"""
 	if path.endswith(".json"):
 		path = path[:-len(".json")]
-	tag: FunctionTag = Mem.ctx.data.function_tags.setdefault(path)
+	tag: TagFile = tag_type.setdefault(path)
 	data: JsonDict = tag.data
 	if not data.get("values"):
-		data["values"] = functions or []
+		data["values"] = values or []
 
 	if prepend:
-		data["values"] = functions + data["values"]
+		data["values"] = values + data["values"]
 	else:
-		data["values"].extend(functions or [])
+		data["values"].extend(values or [])
 	data["values"] = unique_list(data["values"])
 	tag.encoder = super_json_dump
 
+def write_function_tag(path: str, functions: list[Any] | None = None, prepend: bool = False) -> None:
+	""" Write a function tag at the given path.
+
+	Args:
+		path        (str):  The path to the function tag (ex: "namespace:something" for 'data/namespace/tags/function/something.json')
+		functions   (list[Any] | None): The functions to add to the tag
+		prepend     (bool): If the functions should be prepended instead of appended
+	"""
+	write_tag(path, Mem.ctx.data.function_tags, functions, prepend)
+
 
 def read_function(path: str) -> str:
 	""" Read the content of a function at the given path.

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/plugins/archive/__init__.py

@@ -71,8 +71,15 @@ def beet_default(ctx: Context) -> None:
 		# This approach writes pack contents directly to a zip file without modifying the original pack structure
 
 		# First pass: Create the zip file normally
-		with zipfile.ZipFile(archive_path, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zip_file:
-			pack.dump(zip_file)
+		for i in range(10):
+			try:
+				with zipfile.ZipFile(archive_path, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zip_file:
+					pack.dump(zip_file)
+				break
+			except Exception:
+				if i == 9:
+					raise
+				time.sleep(0.5)
 
 		# Second pass: Read all contents and recreate with consistent timestamps
 		# This is necessary because beet's dump() uses origin.open() which bypasses writestr() completely

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/plugins/finalyze/dependencies/__init__.py

@@ -209,7 +209,7 @@ execute if score #{ns}.major load.status matches {major} if score #{ns}.minor lo
 			name: str = value["name"]
 			url: str = value["url"]
 			lib_version: str = ".".join(map(str, value["version"]))
-			decoder_command: str = f'tellraw @a {{"text":"- [{name} (v{lib_version}+)]","color":"gold","clickEvent":{{"action":"open_url","value":"{url}"}}}}'
+			decoder_command: str = f'tellraw @a {{"text":"- [{name} (v{lib_version}+)]","color":"gold","click_event":{{"action":"open_url","url":"{url}"}}}}'
 			decoder_checks += check_version(lib_ns, value, decoder_command)
 
 		# Write check_dependencies.mcfunction

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/plugins/ingame_manual/image_utils.py

@@ -30,14 +30,14 @@ def load_simple_case_no_border(high_res: bool) -> Image.Image:
 	return result
 
 
-def careful_resize(image: Image.Image, max_result_size: int) -> Image.Image:
+def careful_resize(image: Image.Image, max_result_size: int, resampling: Image.Resampling = Image.Resampling.NEAREST) -> Image.Image:
 	"""Resize an image while keeping the aspect ratio"""
 	if image.size[0] >= image.size[1]:
 		factor = max_result_size / image.size[0]
-		return image.resize((max_result_size, int(image.size[1] * factor)), Image.Resampling.NEAREST)
+		return image.resize((max_result_size, int(image.size[1] * factor)), resampling)
 	else:
 		factor = max_result_size / image.size[1]
-		return image.resize((int(image.size[0] * factor), max_result_size), Image.Resampling.NEAREST)
+		return image.resize((int(image.size[0] * factor), max_result_size), resampling)
 
 def add_border(image: Image.Image, border_color: tuple[int, int, int, int], border_size: int, is_rectangle_shape: bool) -> Image.Image:
 	"""Add a border to every part of the image"""

{stewbeet-2.0.22 → stewbeet-2.0.24}/stewbeet/plugins/ingame_manual/main.py

@@ -78,6 +78,7 @@ from .shared_import import (
 	get_page_font,
 	get_page_number,
 )
+from .showcase_image import generate_showcase_images
 
 
 # Utility functions
@@ -635,6 +636,11 @@ def routine():
 				f.write(super_json_dump(book_content))
 			debug(f"Debug book_content at '{relative_path(json_dump_path)}'")
 
+		# Generate showcase images if requested
+		showcase_image: int = manual_config.get("showcase_image", 3)
+		if showcase_image > 0:
+			generate_showcase_images(showcase_image, categories, simple_case)
+
 
 	# Copy the font provider and the generated textures to the resource pack
 	Mem.ctx.assets[Mem.ctx.project_id].fonts["manual"] = Font(source_path=f"{SharedMemory.cache_path}/font/manual.json")

stewbeet-2.0.24/stewbeet/plugins/ingame_manual/showcase_image.py

@@ -0,0 +1,130 @@
+
+# Imports
+import os
+
+from PIL import Image
+from stouputils.io import relative_path
+from stouputils.print import debug, warning
+
+from ...core.__memory__ import Mem
+from .image_utils import careful_resize
+from .shared_import import SharedMemory
+
+
+# Functions
+def calculate_optimal_grid(item_count: int) -> tuple[int, int]:
+	""" Calculate optimal grid dimensions for a given number of items to achieve closest to 16:9 ratio
+
+	Args:
+        item_count (int): The total number of items to arrange in the grid.
+    Returns:
+        tuple[int, int]: The optimal number of rows and columns for the grid.
+	"""
+	if item_count == 0:
+		return 0, 0
+
+	best_ratio_diff: float = float('inf')
+	best_rows, best_cols = 1, item_count
+	target_ratio: float = 16/9
+
+	# Try different configurations
+	for rows in range(1, item_count + 1):
+		cols: int = (item_count + rows - 1) // rows  # Ceiling division
+		if rows * cols >= item_count:
+			ratio: float = cols / rows
+			ratio_diff: float = abs(ratio - target_ratio)
+			if ratio_diff < best_ratio_diff:
+				best_ratio_diff = ratio_diff
+				best_rows, best_cols = rows, cols
+
+	return best_rows, best_cols
+
+def generate_showcase_images(showcase_mode: int, categories: dict[str, list], simple_case: Image.Image):
+	""" Generate showcase images based on the showcase_mode parameter
+
+    Args:
+        showcase_mode   (int): Mode for generating showcase images:
+            1 - Showcase items in the manual
+            2 - Showcase all items, even those not in the manual
+            3 - Showcase both manual items and all items
+        categories      (dict[str, list]): Dictionary of categories with items.
+        simple_case     (Image.Image): Image of a simple case to use as background for items.
+	"""
+	# Get items for manual (mode 1 or 3)
+	if showcase_mode in [1, 3]:
+		manual_items: list[str] = []
+		for items in categories.values():
+			manual_items.extend(items)
+		if manual_items:
+			create_showcase_image(manual_items, "all_manual_items.jpg", simple_case)
+
+	# Get all items (mode 2 or 3)
+	if showcase_mode in [2, 3]:
+		all_items: list[str] = list(Mem.definitions.keys())
+		if all_items:
+			create_showcase_image(all_items, "all_items.jpg", simple_case)
+
+def create_showcase_image(items: list[str], filename: str, simple_case: Image.Image):
+	""" Create a showcase image with items arranged in optimal grid for 16:9 ratio
+
+    Args:
+        items           (list[str]): List of item IDs to include in the showcase.
+        filename        (str): Name of the output image file.
+        simple_case     (Image.Image): Image of a simple case to use as background for items.
+	"""
+	if not items:
+		return
+
+	rows, cols = calculate_optimal_grid(len(items))
+
+	# Big case size to make sure textures are not distorted
+	case_size: int = 512
+
+	# Resize the simple case to match our calculated case size
+	resized_case: Image.Image = simple_case.resize((case_size, case_size), Image.Resampling.NEAREST)
+
+	# Calculate image dimensions with border
+	img_width: int = cols * case_size
+	img_height: int = rows * case_size
+
+	# Create image
+	showcase_image: Image.Image = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 0))
+
+	# Place items
+	for i, item in enumerate(items):
+		row: int = i // cols
+		col: int = i % cols
+
+		x: int = col * case_size
+		y: int = row * case_size
+
+		# Get item texture
+		texture_path: str = f"{SharedMemory.cache_path}/items/{Mem.ctx.project_id}/{item}.png"
+		if os.path.exists(texture_path):
+			item_image: Image.Image = Image.open(texture_path)
+		else:
+			warning(f"Missing texture at '{texture_path}', using empty texture for showcase")
+			item_image: Image.Image = Image.new("RGBA", (1, 1), (0, 0, 0, 0))
+
+		# Resize item image to 89% of case size
+		target_size: int = int(case_size * (0.890625))
+		resized_item: Image.Image = careful_resize(item_image, target_size)
+
+		# Center the resized item image within the case
+		item_x: int = x + (case_size - resized_item.size[0]) // 2
+		item_y: int = y + (case_size - resized_item.size[1]) // 2
+
+		# Paste the resized case and the item image
+		showcase_image.paste(resized_case, (x, y))
+		if resized_item.mode == "RGBA":
+			mask: Image.Image = resized_item.split()[3]
+			showcase_image.paste(resized_item, (item_x, item_y), mask)
+		else:
+			showcase_image.paste(resized_item, (item_x, item_y))
+
+	# Save to output directory
+	os.makedirs(Mem.ctx.output_directory, exist_ok=True)
+	output_path = os.path.join(Mem.ctx.output_directory, filename)
+	showcase_image.save(output_path, "PNG")
+	debug(f"Generated showcase image: {relative_path(output_path)} ({rows}x{cols} grid, {len(items)} items)")
+