stewbeet 2.2.8__tar.gz → 2.2.9__tar.gz

{stewbeet-2.2.8 → stewbeet-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 2.2.8
+Version: 2.2.9
 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.2.8 → stewbeet-2.2.9}/pyproject.toml

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

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/core/constants.py

@@ -87,6 +87,7 @@ NOT_COMPONENTS: list[str] = [							# Keys that should not be considered as comp
 FACES: tuple[str, ...] = ("down", "up", "north", "south", "west", "east")						# Faces of a block, used for resource pack and blocks orientation
 SIDES: tuple[str, ...] = ("_bottom", "_top", "_front", "_back", "_left", "_right", "_side")	# Sides of a block, used for resource pack
 DOWNLOAD_VANILLA_ASSETS_RAW = "https://raw.githubusercontent.com/edayot/renders/renders/resourcepack/assets/minecraft/textures/render"
+DOWNLOAD_VANILLA_ASSETS_SPECIAL_RAW = "https://raw.githubusercontent.com/edayot/renders/renders-special/resourcepack/assets/minecraft/textures/render"
 DOWNLOAD_VANILLA_ASSETS_SOURCE = "https://github.com/edayot/renders/tree/renders/resourcepack/assets/minecraft/textures/render"
 CUSTOM_BLOCK_HEAD_CUBE_RADIUS: tuple[int, int, int] = (16, 16, 16)	# Size of the region to check around the player when placing a CUSTOM_BLOCK_HEAD
 BLOCKS_WITH_INTERFACES: list[str] = [	# List of blocks that are containers and have an interface

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/core/definitions_helper/completion.py

@@ -107,3 +107,15 @@ def add_smithed_ignore_vanilla_behaviours_convention() -> None:
 		data["custom_data"].smithed.ignore.functionality = True # pyright: ignore[reportUnknownMemberType]
 		data["custom_data"].smithed.ignore.crafting = True # pyright: ignore[reportUnknownMemberType]
 
+# Set manual components
+def set_manual_components(white_list: list[str]) -> None:
+	""" Override the components to include in the manual when hovering items.
+
+	Args:
+		white_list	(list[str]):	The list of components to include.
+	"""
+	if not white_list:
+		return
+	from ...plugins.ingame_manual.shared_import import SharedMemory
+	SharedMemory.components_to_include = white_list
+

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/core/ingredients.py

@@ -80,27 +80,30 @@ def ingr_to_id(ingredient: JsonDict, add_namespace: bool = True) -> str:
 	"""
 	if isinstance(ingredient, str):
 		ingredient = {"item": ingredient}
-	if ingredient.get("item"):
-		if not add_namespace:
-			return ingredient["item"].split(":")[1]
-		return ingredient["item"]
-	else:
-		custom_data: JsonDict = ingredient["components"]["minecraft:custom_data"]
-		namespace: str = ""
-		id: str = ""
-		for cd_ns, cd_data in custom_data.items():
-			if isinstance(cd_data, dict):
-				cd_data = cast(JsonDict, cd_data)
-				values: list[Any] = list(cd_data.values())
-				if isinstance(values[0], bool):
-					namespace = cd_ns
-					id = next(iter(cd_data.keys()))
-					break
-		if not namespace:
-			error(f"No namespace found in custom data: {custom_data}, ingredient: {ingredient}")
-		if add_namespace:
-			return namespace + ":" + id
-		return id
+	for k in ("item", "id"):
+		if ingredient.get(k):
+			if not add_namespace and ":" in ingredient[k]:
+				return ingredient[k].split(":")[1]
+			elif add_namespace and ":" not in ingredient[k]:
+				return "minecraft:" + ingredient[k]
+			return ingredient[k]
+
+	custom_data: JsonDict = ingredient["components"]["minecraft:custom_data"]
+	namespace: str = ""
+	id: str = ""
+	for cd_ns, cd_data in custom_data.items():
+		if isinstance(cd_data, dict):
+			cd_data = cast(JsonDict, cd_data)
+			values: list[Any] = list(cd_data.values())
+			if isinstance(values[0], bool):
+				namespace = cd_ns
+				id = next(iter(cd_data.keys()))
+				break
+	if not namespace:
+		error(f"No namespace found in custom data: {custom_data}, ingredient: {ingredient}")
+	if add_namespace:
+		return namespace + ":" + id
+	return id
 
 # Mainly used for recipes
 @simple_cache
@@ -185,34 +188,51 @@ def get_item_from_ingredient(ingredient: JsonDict) -> JsonDict:
 
 # Make a loot table
 @simple_cache
-def loot_table_from_ingredient(result_ingredient: JsonDict, result_count: int) -> str:
+def loot_table_from_ingredient(result_ingredient: JsonDict, result_count: int | dict) -> str:
+	""" Get the loot table for an ingredient dict
+	Args:
+		result_ingredient (dict): The ingredient dict
+			ex: {"item": "minecraft:stick"}
+		result_count (int|dict): The count of the result item, can be an int or a dict for random counts
+			ex: 1
+			ex: {"type": "minecraft:uniform","min": 4,"max": 6}
+	Returns:
+		str: The loot table path, ex: "my_datapack:i/stick"
+	"""
 
 	# If item from this datapack
 	item: str = ingr_to_id(result_ingredient)
 	if item.startswith(Mem.ctx.project_id):
 		item = item.split(":")[1]
 		loot_table = f"{Mem.ctx.project_id}:i/{item}"
-		if result_count > 1:
+		if isinstance(result_count, int) and result_count > 1:
 			loot_table += f"_x{result_count}"
+		elif isinstance(result_count, dict):
+			minimum = result_count.get("min", 1)
+			maximum = result_count.get("max", 1)
+			if maximum > 1:
+				loot_table += f"_x{minimum}to{maximum}"
 		return loot_table
 
 	namespace, item = item.split(":")
 	loot_table = f"{Mem.ctx.project_id}:recipes/{namespace}/{item}"
-	if result_count > 1:
+	if isinstance(result_count, int) and result_count > 1:
 		loot_table += f"_x{result_count}"
+	elif isinstance(result_count, dict):
+		minimum = result_count.get("min", 1)
+		maximum = result_count.get("max", 1)
+		if maximum > 1:
+			loot_table += f"_x{minimum}to{maximum}"
 
 	# If item from another datapack, generate the loot table
-	path: str = f"{Mem.ctx.project_id}:recipes/{namespace}/{item}"
-	if result_count > 1:
-		path += f"_x{result_count}"
 	if namespace != "minecraft":
 		file: JsonDict = {"pools":[{"rolls":1,"entries":[{"type":"minecraft:loot_table","value": f"{Mem.ctx.project_id}:external/{namespace}/{item}"}] }] }
 	else:
 		file: JsonDict = {"pools":[{"rolls":1,"entries":[{"type":"minecraft:item","name":f"{namespace}:{item}"}] }] }
-	if result_count > 1:
+	if (isinstance(result_count, int) and result_count > 1) or isinstance(result_count, dict):
 		file["pools"][0]["entries"][0]["functions"] = [{"function": "minecraft:set_count","count": result_count}]
 
-	Mem.ctx.data[f"{Mem.ctx.project_id}:recipes/{namespace}/{item}"] = LootTable(super_json_dump(file, max_level=9))
+	Mem.ctx.data[loot_table] = LootTable(super_json_dump(file, max_level=9))
 	return loot_table
 
 @simple_cache

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/datapack/custom_blocks/__init__.py

@@ -137,14 +137,16 @@ execute if score #rotation {ns}.data matches 0 if predicate {ns}:facing/west run
 # Advancement revoke
 advancement revoke @s only {ns}:custom_block_alternative/{item}
 
-# Execute the place function as and at the new placed item frame
-tag @s add {ns}.to_refund
+# Execute the place function as and at the new placed item frame""")
+				if "id" not in block:
+					write_function(f"{ns}:custom_blocks/{item}/search", f"execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {ns}:custom_blocks/{item}/place_main")
+				# Make place check function (only if "id" is in VANILLA_BLOCK)
+				else:
+					write_function(f"{ns}:custom_blocks/{item}/search", f"""tag @s add {ns}.to_refund
 execute as @e[type=item_frame,tag={ns}.new,tag={ns}.{item}] at @s run function {ns}:custom_blocks/{item}/place_check
 tag @s remove {ns}.to_refund
 """)
-
-				# Make place check function
-				write_function(f"{ns}:custom_blocks/{item}/place_check", f"""
+					write_function(f"{ns}:custom_blocks/{item}/place_check", f"""
 # Check if there is air block at the position
 execute if block ~ ~ ~ air run return run function {ns}:custom_blocks/{item}/place_main
 

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/finalyze/check_unused_textures/__init__.py

@@ -30,14 +30,16 @@ def beet_default(ctx: Context) -> None:
 	# Ex: {'some_folder/dirt.png', 'stone.png', ...}
 	textures: set[str] = {relative_path(str(p), textures_folder) for p in Path(textures_folder).rglob("*.png")}
 
-	# 2) For each texture, check if any of the ctx.assets.textures endswith the texture path.
+	# 2) For each texture, check if any of the ctx.assets.textures matches the texture filename.
 	unused_paths: set[str] = set()
 	for path in textures:
+		# Get just the filename without extension for comparison
+		filename_no_ext: str = os.path.splitext(os.path.basename(path))[0]
 		no_extension_path: str = os.path.splitext(path)[0]
 		if not any(
-			str(texture.source_path).endswith(no_extension_path) if isinstance(texture, Texture)
+			(str(texture.source_path).endswith(no_extension_path) or filename_no_ext in str(texture.source_path)) if isinstance(texture, Texture)
 			else (
-				texture.endswith(no_extension_path) if isinstance(texture, str)
+				(texture.endswith(no_extension_path) or filename_no_ext in texture) if isinstance(texture, str)
 				else False
 			)
 			for texture in cast(list[Any], ctx.assets.textures)

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/book_components.py

@@ -10,7 +10,7 @@ from stouputils.print import error, warning
 from ...core.__memory__ import Mem
 from ...core.ingredients import ingr_to_id
 from .image_utils import generate_high_res_font
-from .shared_import import COMPONENTS_TO_INCLUDE, NONE_FONT, SharedMemory, get_page_number
+from .shared_import import NONE_FONT, SharedMemory, get_page_number
 
 
 # Call the previous function
@@ -107,7 +107,7 @@ def get_item_component(ingredient: str | JsonDict, only_those_components: list[s
 					components[key] = item[key]
 		else:
 			for key, value in item.items():
-				if key in COMPONENTS_TO_INCLUDE:
+				if key in SharedMemory.components_to_include:
 					components[key] = value
 		formatted["hover_event"]["components"] = components
 

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/image_utils.py

@@ -6,7 +6,7 @@ from typing import Any, cast
 
 from PIL import Image, ImageDraw, ImageFont
 
-from ...core.__memory__ import Mem
+from ...core.__memory__ import JsonDict, Mem
 from .shared_import import (
 	MICRO_NONE_FONT,
 	TEMPLATES_PATH,
@@ -101,7 +101,7 @@ def image_count(count: int | str) -> Image.Image:
 	return img
 
 # Generate high res image for item
-def generate_high_res_font(item: str, item_image: Image.Image, count: int = 1) -> str:
+def generate_high_res_font(item: str, item_image: Image.Image, count: int | str | JsonDict = 1) -> str:
 	""" Generate the high res font to display in the manual for the item
 	Args:
 		item		(str):		The name of the item, ex: "adamantium_fragment"
@@ -111,6 +111,8 @@ def generate_high_res_font(item: str, item_image: Image.Image, count: int = 1) -
 		str: The font to the generated texture
 	"""
 	font = get_next_font()
+	if isinstance(count, dict):
+		count = f"{count.get('min', 1)}-{count.get('max', 1)}"
 	item = f"{item}_{str(count).replace('-', '_')}" if isinstance(count, str) or count > 1 else item
 
 	# Get output path

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/iso_renders.py

@@ -16,6 +16,7 @@ from ...core.__memory__ import Mem
 from ...core.constants import (
 	DOWNLOAD_VANILLA_ASSETS_RAW,
 	DOWNLOAD_VANILLA_ASSETS_SOURCE,
+	DOWNLOAD_VANILLA_ASSETS_SPECIAL_RAW,
 	RESULT_OF_CRAFTING,
 	USED_FOR_CRAFTING,
 )
@@ -97,20 +98,16 @@ def generate_all_iso_renders():
 		if not destination:
 			destination = f"{path}/minecraft/{item}.png"
 		if not (os.path.exists(destination) and cache_assets):	# If not downloaded yet or not using cache
-			link: str = f"{DOWNLOAD_VANILLA_ASSETS_RAW}/item/{item}.png"
-			response = requests.get(link)
-			if response.status_code == 200:
-				with super_open(destination, "wb") as file:
-					file.write(response.content)
-			else:
-				link = link.replace("item/", "block/")
-				response = requests.get(link)
-				if response.status_code == 200:
-					with super_open(destination, "wb") as file:
-						file.write(response.content)
-				else:
-					warning(f"Failed to download texture '{link}', please add it manually to '{destination}'")
-					warning(f"Suggestion link: '{DOWNLOAD_VANILLA_ASSETS_SOURCE}'")
+			for base_link in (DOWNLOAD_VANILLA_ASSETS_SPECIAL_RAW, DOWNLOAD_VANILLA_ASSETS_RAW):
+				for folder in ["item", "block", "items"]:
+					link: str = f"{base_link}/{folder}/{item}.png"
+					response = requests.get(link)
+					if response.status_code == 200:
+						with super_open(destination, "wb") as file:
+							return file.write(response.content)
+			# If all attempts failed
+			warning(f"Failed to download texture for '{item}', please add it manually to '{destination}'")
+			warning(f"Suggestion link: '{DOWNLOAD_VANILLA_ASSETS_SOURCE}'")
 
 	# Multithread the download
 	multithreading(download_item, used_vanilla_items, max_workers=min(32, len(used_vanilla_items)))

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/main.py

@@ -288,7 +288,7 @@ def routine():
 					x += simple_case.size[0]
 
 					# Add the click_event part to the line and add the 2 times the line if enough items
-					component = get_item_component(item, only_those_components=["item_name", "custom_name"])
+					component = get_item_component(item, only_those_components=["item_name", "custom_name", "attribute_modifiers"])
 					component["text"] = MEDIUM_NONE_FONT if not SharedMemory.high_resolution else high_res_font
 					line.append(component)
 					if len(line) == MAX_ITEMS_PER_ROW:
@@ -441,6 +441,12 @@ def routine():
 						if craft["type"] == "crafting_shapeless":
 							craft = convert_shapeless_to_shaped(craft)
 
+						# Skip if result is same as previous result
+						current_result: Any | None = craft.get("result")
+						if current_result and current_result == previous_result and craft["type"] != "mining":
+							continue
+						previous_result = current_result
+
 						# Get breaklines
 						breaklines = 3
 						if "shape" in craft:
@@ -476,7 +482,7 @@ def routine():
 								PULVERIZING: "SimplEnergy Pulverizing"
 							}
 							recipe_title = recipe_type_names.get(craft["type"], craft["type"].replace("_", " ").title())
-							hover_text.insert(0, {"text": f"{recipe_title}\n", "color": "yellow"})
+							hover_text.append({"text": f"\n{recipe_title}", "color": "yellow"})
 
 						# Append ingredients
 						if craft["type"] == "mining":
@@ -532,12 +538,6 @@ def routine():
 								hover_text.append({"text": "\n- Pattern: ", "color": "gray"})
 								hover_text.append({"text": pattern_name, "color": "gray"})
 
-						# Skip if result is same as previous result
-						current_result: Any | None = craft.get("result")
-						if current_result and current_result == previous_result and craft["type"] != "mining":
-							continue
-						previous_result = current_result
-
 						# Add the craft to the content
 						result_or_ingredient = WIKI_RESULT_OF_CRAFT_FONT if "result" not in craft else generate_wiki_font_for_ingr(name, craft)
 						info_buttons.append({
@@ -595,7 +595,7 @@ def routine():
 
 						# If there are more than buttons_limit buttons, remove lowest priority ones until there is buttons_limit left
 						while len(info_buttons) > buttons_limit:
-							lowest_priority: int = min(info_buttons[::-1], key=lambda x: x.get("priority", 1))
+							lowest_priority: JsonDict = min(info_buttons[::-1], key=lambda x: x.get("priority", 1))
 							info_buttons.remove(lowest_priority)
 
 						# Keep only the last buttons_limit buttons (maximum that can be displayed with 5 per line and 4 lines)

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/other_utils.py

@@ -1,8 +1,6 @@
 
 # ruff: noqa: E501
 # Imports
-from typing import cast
-
 from beet.core.utils import JsonDict
 from stouputils.decorators import simple_cache
 
@@ -32,22 +30,24 @@ def convert_shapeless_to_shaped(craft: JsonDict) -> JsonDict:
 	if craft.get("result"):
 		shaped_recipe["result"] = craft["result"]
 
-	# Get all ingredients to the dictionary
+	# Get all ingredients to the dictionary and map each ingredient to a key, preserving order
 	next_key: str = "A"
-	for ingr in shapeless_ingredients:
-		key: str = next_key
+	ingredient_to_key: dict[str, str] = {}
+	ordered_keys: list[str] = []
 
-		# Check if the ingredient is already in the shaped recipe, if so stop early
-		for new_key, new_ingr in shaped_recipe["ingredients"].items():
-			if str(ingr) == str(new_ingr):
-				key = new_key	# This will skip the next condition below
-				break
+	for ingr in shapeless_ingredients:
+		ingr_str = str(ingr)
 
-		# If the key is still the next key, it means it's a new ingredient, add it to the dictionary and update the next key
-		if key == next_key:
+		# Check if we've already seen this ingredient
+		if ingr_str not in ingredient_to_key:
+			# New ingredient, assign it the next key
+			ingredient_to_key[ingr_str] = next_key
 			shaped_recipe["ingredients"][next_key] = ingr
 			next_key = chr(ord(next_key) + 1)
 
+		# Record the key for this position (preserving order)
+		ordered_keys.append(ingredient_to_key[ingr_str])
+
 	# Make the shape of the craft, with an exception when 2 materials to put one alone in the center
 	if len(shaped_recipe["ingredients"]) == 2 and total_items in (5, 9):
 
@@ -61,21 +61,21 @@ def convert_shapeless_to_shaped(craft: JsonDict) -> JsonDict:
 		elif total_items == 5:
 			shaped_recipe["shape"] = [f" {big} ", big+other+big, f" {big} "]
 	else:
-
-		# For each ingredient, add to the shape depending on the occurences
-		shaped_recipe["shape"] = cast(list[str], [])
-		for key, ingr in shaped_recipe["ingredients"].items():
-			for ingr_craft in craft["ingredients"]:
-				if str(ingr_craft) == str(ingr):
-					shaped_recipe["shape"].append(key)
-
-		# Fix the shape (ex: ["A","A","A","B","B","B","C","C","C"] -> ["AAA","BBB","CCC"])
-		# ex 2: ["A","B","C","D"] -> ["AB","CD"]
-		col_size = 3
-		if len(shaped_recipe["shape"]) <= 4:
+		# Determine the grid size based on total items
+		# Perfect squares: 1, 4, 9 -> use sqrt as col_size
+		# Otherwise: use 3 for <=9 items, 2 for <=4 items
+		import math
+		sqrt_items = int(math.sqrt(total_items))
+		if sqrt_items * sqrt_items == total_items:
+			# Perfect square
+			col_size = sqrt_items
+		elif total_items <= 4:
 			col_size = 2
-		ranged = range(0, len(shaped_recipe["shape"]), col_size)
-		shaped_recipe["shape"] = ["".join(shaped_recipe["shape"][i:i + col_size]) for i in ranged]
+		else:
+			col_size = 3
+
+		# Build the shape preserving the original order
+		shaped_recipe["shape"] = ["".join(ordered_keys[i:i + col_size]) for i in range(0, len(ordered_keys), col_size)]
 
 	# Return the shaped craft
 	return shaped_recipe

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/ingame_manual/shared_import.py

@@ -23,7 +23,6 @@ def get_next_font() -> str:	# Returns an incrementing value for each craft
 
 
 # Constants
-COMPONENTS_TO_INCLUDE: list[str] = ["item_name", "lore", "custom_name", "damage", "max_damage"]
 SQUARE_SIZE: int = 32
 MANUAL_ASSETS_PATH: str = clean_path(os.path.dirname(os.path.realpath(__file__)) + "/")
 TEMPLATES_PATH: str = MANUAL_ASSETS_PATH + "templates"
@@ -67,6 +66,7 @@ HOVER_EQUIVALENTS: dict[str, str] = {
 
 # Global variables
 class SharedMemory:
+	components_to_include: list[str] = ["item_name", "lore", "custom_name", "damage", "max_damage"]
 	next_craft_font: int = 0x8000
 	font_providers: list[JsonDict] = []
 	manual_pages: list[JsonDict] = []

{stewbeet-2.2.8 → stewbeet-2.2.9}/stewbeet/plugins/verify_definitions/__init__.py

@@ -247,10 +247,6 @@ def beet_default(ctx: Context) -> None:
 							if not recipe.get("cookingtime") or not isinstance(recipe["cookingtime"], int):
 								errors.append(f"Recipe #{i} in RESULT_OF_CRAFTING should have an int 'cookingtime' key for '{item}'")
 
-					# Check the result count
-					if (not recipe.get("result_count") or not isinstance(recipe["result_count"], int)) and (recipe.get("type") not in ("smithing_trim",)):
-						errors.append(f"Recipe #{i} in RESULT_OF_CRAFTING should have an int 'result_count' key for '{item}'")
-
 		# Check the PAINTING_DATA key
 		if data.get(PAINTING_DATA):
 			if data["id"] != "minecraft:painting":