stewbeet 2.0.7__tar.gz → 2.0.8__tar.gz

{stewbeet-2.0.7 → stewbeet-2.0.8}/PKG-INFO

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

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

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/core/utils/sounds.py

@@ -9,6 +9,19 @@ from stouputils.io import super_json_dump
 def add_sound(ctx: Context, sounds: Sound | dict[str, Sound], name: str, ns: str = ""):
 	""" Add a sound to the resource pack.
 
+	Example usage:
+
+	```python
+	from beet import Context, Sound
+	from stewbeet.core.utils.sounds import add_sound
+
+	def beet_default(ctx: Context):
+		sound = Sound("path/to/sound.ogg", volume=1.0, pitch=1.0)
+		add_sound(ctx, sound, "my_sound")
+		add_sound(ctx, {"my_sound_1": sound, "my_sound_2": sound}, "my_sounds")
+		add_sound(ctx, sound, "my_sound", ns="another_namespace")
+	```
+
 	Args:
 		ctx    (Context):                   The beet context.
 		sounds (Sound | dict[str, Sound]):  The sound object(s) to add. Can be a single Sound or a dict mapping local names to Sounds.

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/archive/__init__.py

@@ -1,33 +1,3 @@
-"""
-StewBeet Archive Plugin
-
-This plugin replaces the legacy `make_archive.py` system with a beet-compatible implementation.
-Instead of using the old `FILES_TO_WRITE` global dictionary approach, this plugin leverages
-beet's native Context and pack management system.
-
-Key improvements over the legacy system:
-1. Uses beet's Context.packs to access generated data and resource packs
-2. Uses pack.dump() to create zip archives without interfering with existing pack directories
-3. Integrates with beet's output directory management
-4. Provides proper error handling for file operations
-5. Uses beet cache .gitignore file modification time for consistent, reproducible timestamps
-
-The plugin automatically:
-- Detects all generated packs (data pack and resource pack)
-- Creates zip archives with consistent timestamps based on beet cache .gitignore file
-- Applies deterministic compression settings for reproducible builds
-- Saves archives to the configured output directory
-- Preserves existing pack directory structure
-
-Timestamp Strategy:
-The plugin uses the modification time of the `.beet_cache/.gitignore` file to ensure
-all zip entries have consistent timestamps, making the archives reproducible and
-deterministic across builds. This approach is more reliable than searching for
-pack.mcmeta files in the output directory.
-
-This replaces the legacy make_archive() function calls and integrates seamlessly
-with beet's plugin architecture and build pipeline without deleting the original pack folders.
-"""
 
 # Imports
 import os

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/auto/lang_file/__init__.py

@@ -1,39 +1,37 @@
-
-# Imports
-from beet import Advancement, Context, Function, ItemModifier, Language, LootTable
-from stouputils.decorators import measure_time
-from stouputils.io import super_json_dump
-from stouputils.parallel import multithreading
-from stouputils.print import BLUE, progress
-
-from .utils import handle_file, lang
-
-
-# Main entry point
-@measure_time(progress, message="Execution time of 'stewbeet.plugins.auto.lang_file'")
-def beet_default(ctx: Context):
-	""" Main entry point for the lang file plugin.
-	This plugin handles language file generation for the datapack.
-
-	Args:
-		ctx (Context): The beet context.
-	"""
-	# Get all functions and loot tables
-	files_to_process: dict[str, Function | LootTable] = {}
-	files_to_process.update(ctx.data.functions)
-	files_to_process.update(ctx.data.loot_tables)
-	files_to_process.update(ctx.data.item_modifiers)
-	files_to_process.update(ctx.data.advancements)
-
-	# Process all files
-	args: list[tuple[Context, str, Function | LootTable | ItemModifier, Advancement]] = [
-		(ctx, file, content) for (file, content) in files_to_process.items()
-		if True
-	]
-	multithreading(handle_file, args, use_starmap=True, desc="Generating lang file", max_workers=min(32, len(args)), color=BLUE)
-
-	# Update the lang file
-	lang.update(ctx.assets.languages.get("minecraft:en_us", Language()).data)
-	ctx.assets.languages["minecraft:en_us"] = Language(super_json_dump(lang))
-	pass
-
+
+# Imports
+from beet import Context, Language, TextFileBase
+from stouputils.decorators import measure_time
+from stouputils.io import super_json_dump
+from stouputils.parallel import multithreading
+from stouputils.print import BLUE, progress
+
+from .utils import handle_file, lang
+
+
+# Main entry point
+@measure_time(progress, message="Execution time of 'stewbeet.plugins.auto.lang_file'")
+def beet_default(ctx: Context):
+	""" Main entry point for the lang file plugin.
+	This plugin handles language file generation for the datapack.
+
+	Args:
+		ctx (Context): The beet context.
+	"""
+	# Get all functions and loot tables
+	files_to_process: dict[str, TextFileBase] = {}
+	files_to_process.update(ctx.data.loot_tables)	# Idk why, but this is needed to ensure loot tables are processed
+	files_to_process.update(dict(ctx.data.all()))
+
+	# Process all files
+	args: list[tuple[Context, str, TextFileBase]] = [
+		(ctx, content) for content in files_to_process.values()
+		if isinstance(content, TextFileBase)
+	]
+	multithreading(handle_file, args, use_starmap=True, desc="Generating lang file", max_workers=min(32, len(args)), color=BLUE)
+
+	# Update the lang file
+	lang.update(ctx.assets.languages.get("minecraft:en_us", Language()).data)
+	ctx.assets.languages["minecraft:en_us"] = Language(super_json_dump(lang))
+	pass
+

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/auto/lang_file/utils.py

@@ -2,7 +2,7 @@
 # Imports
 import re
 
-from beet import Advancement, Context, Function, ItemModifier, LootTable
+from beet import Context, TextFileBase
 from stouputils.decorators import simple_cache
 
 # Prepare lang dictionary and lang_format function
@@ -55,22 +55,20 @@ def lang_format(ctx: Context, text: str) -> tuple[str, str]:
 	return key, re.sub(r"[._]", "", alpha_num)
 
 
-def handle_file(ctx: Context, file: str, content: Function | LootTable | ItemModifier | Advancement) -> None:
+def handle_file(ctx: Context, content: TextFileBase) -> None:
 	""" Process a file to extract and replace text with lang keys.
 
 	Args:
-		ctx      (Context):              The context containing project information.
-		file     (str):                  The path to the file being processed.
-		content  (Function | LootTable): The content of the file to process.
+		ctx      (Context):      The context containing project information.
+		content  (TextFileBase): The content of the file to process.
 
 	Returns:
 		None: The function modifies the content in place.
 	"""
 	# Read content from supported beet types
 	#	Function, LootTable, ItemModifier or Advancement
-	if isinstance(content, Function) or isinstance(content, LootTable) \
-		or isinstance(content, ItemModifier) or isinstance(content, Advancement):
-		string: str = content.text
+	if isinstance(content, TextFileBase):
+		string: str = str(content.text)
 	else:
 		raise ValueError(f"Unsupported content type: {type(content)}")
 
@@ -97,13 +95,7 @@ def handle_file(ctx: Context, file: str, content: Function | LootTable | ItemMod
 		new_fragment: str = f'{quote}translate{quote}: {quote}{key_for_lang}{quote}'
 		string = string[:start] + new_fragment + string[end:]
 
-	# Write the new content back to the appropriate context data
-	if isinstance(content, Function):
-		ctx.data.functions[file] = Function(string)
-	elif isinstance(content, LootTable):
-		ctx.data.loot_tables[file] = LootTable(string)
-	elif isinstance(content, ItemModifier):
-		ctx.data.item_modifiers[file] = ItemModifier(string)
-	elif isinstance(content, Advancement):
-		ctx.data.advancements[file] = Advancement(string)
+	# Update the content
+	if string != str(content.text):
+		content.text = string
 

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/copy_to_destination/__init__.py

@@ -70,10 +70,9 @@ def _copy_datapacks(output_path: str, project_name_simple: str, libs_folder: str
 
 	if os.path.exists(main_datapack):
 		for dest in destinations:
-			os.makedirs(dest, exist_ok=True)
 			dest_file = relative_path(f"{dest}/{os.path.basename(main_datapack)}")
-			_copy_with_retry(main_datapack, dest_file)
-			info(f"Copied normal datapack to: '{dest_file}'")
+			if _copy_with_retry(main_datapack, dest_file):
+				info(f"Copied normal datapack to: '{dest_file}'")
 
 	# Copy all library datapacks
 	if libs_folder:
@@ -83,10 +82,9 @@ def _copy_datapacks(output_path: str, project_name_simple: str, libs_folder: str
 				if lib_zip.endswith('.zip'):
 					lib_zip_path = relative_path(f"{libs_datapack_path}/{lib_zip}")
 					for dest in destinations:
-						os.makedirs(dest, exist_ok=True)
 						dest_file = relative_path(f"{dest}/{lib_zip}")
-						_copy_with_retry(lib_zip_path, dest_file)
-						info(f"Copied library datapack to: '{dest_file}'")
+						if _copy_with_retry(lib_zip_path, dest_file):
+							info(f"Copied library datapack to: '{dest_file}'")
 
 
 def _copy_resource_packs(output_path: str, project_name_simple: str, destinations: list[str]) -> None:
@@ -105,14 +103,13 @@ def _copy_resource_packs(output_path: str, project_name_simple: str, destination
 
 	if os.path.exists(resource_pack_to_copy):
 		for dest in destinations:
-			os.makedirs(dest, exist_ok=True)
 			# Use original name (without _with_libs suffix) for the destination
 			with_libs = "_with_libs" if resource_pack_to_copy == merged_resource_pack else ""
 			dest_name = f"{project_name_simple}_resource_pack{with_libs}.zip"
 			dest_file = relative_path(f"{dest}/{dest_name}")
-			_copy_with_retry(resource_pack_to_copy, dest_file)
-			pack_type = "merged" if resource_pack_to_copy == merged_resource_pack else "normal"
-			info(f"Copied {pack_type} resource pack to: '{dest_file}'")
+			if _copy_with_retry(resource_pack_to_copy, dest_file):
+				pack_type = "merged" if resource_pack_to_copy == merged_resource_pack else "normal"
+				info(f"Copied {pack_type} resource pack to: '{dest_file}'")
 
 
 def _copy_official_libs(datapack_destinations: list[str]) -> None:
@@ -136,13 +133,12 @@ def _copy_official_libs(datapack_destinations: list[str]) -> None:
 				lib_zip_path = relative_path(f"{official_datapack_path}/{lib_zip}")
 				if os.path.exists(lib_zip_path):
 					for dest in datapack_destinations:
-						os.makedirs(dest, exist_ok=True)
 						dest_file = relative_path(f"{dest}/{lib_zip}")
-						_copy_with_retry(lib_zip_path, dest_file)
-						info(f"Copied official library to: '{dest_file}'")
+						if _copy_with_retry(lib_zip_path, dest_file):
+							info(f"Copied official library to: '{dest_file}'")
 
 
-def _copy_with_retry(src: str, dst: str, max_retries: int = 10, delay: float = 1.0) -> None:
+def _copy_with_retry(src: str, dst: str, max_retries: int = 10, delay: float = 1.0) -> bool:
 	""" Copy a file with retry logic to handle permission errors.
 
 	Args:
@@ -150,6 +146,8 @@ def _copy_with_retry(src: str, dst: str, max_retries: int = 10, delay: float = 1
 		dst (str): Destination file path.
 		max_retries (int): Maximum number of retry attempts.
 		delay (float): Delay in seconds between retries.
+	Returns:
+		bool: True if the copy was successful, False if it failed after all retries.
 	"""
 	# Delete the destination file if it exists (optional)
 	if os.path.exists(dst):
@@ -159,16 +157,20 @@ def _copy_with_retry(src: str, dst: str, max_retries: int = 10, delay: float = 1
 			pass
 
 	# Ensure the destination directory exists
-	os.makedirs(os.path.dirname(dst), exist_ok=True)
+	dest_dir = os.path.dirname(dst)
+	if not os.path.exists(dest_dir):
+		warning(f"Destination directory '{dest_dir}' does not exist. Cannot copy file '{src}'.")
+		return False
 
 	# Attempt to copy the file with retries
 	for attempt in range(max_retries):
 		try:
 			shutil.copy(src, dst)
-			return
+			return True
 		except PermissionError as e:
 			if attempt == max_retries - 1:
 				raise e
 			warning(f"Failed to copy '{src}' the destinations ({e.__class__.__name__}). Retrying in {delay} seconds...")
 			time.sleep(delay)
+	return False  # If all retries failed, return False
 

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/datapack/custom_blocks/__init__.py

@@ -401,18 +401,28 @@ execute as @e[tag={ns}.custom_block,dx=0,dy=0,dz=0] at @s run function {ns}:cust
 			)
 			adv["rewards"]["function"] = f"{ns}:custom_blocks/_player_head/search_{item}"
 			adv_obj = Advancement(adv)
-			adv_obj.encoder = super_json_dump
+			adv_obj.encoder = lambda x: super_json_dump(x, max_level=-1)
 			ctx.data[ns].advancements[f"custom_block_head/{item}"] = adv_obj
 
-			# Make search function
+			## Make search function
 			content = "# Search where the head has been placed\n"
 			mid_x, mid_y, mid_z = [x // 2 for x in CUSTOM_BLOCK_HEAD_CUBE_RADIUS]
-			content += f"""
-for x in range({-mid_x}, {mid_x + 1}):
-	for y in range({-mid_y}, {mid_y + 1}):
-		for z in range({-mid_z}, {mid_z + 1}):
-			execute positioned ~x ~y ~z if data block ~ ~ ~ components.\"minecraft:custom_data\".{ns}.{item} run function {ns}:custom_blocks/{item}/place_main
-"""
+
+			# Generate main search function that calls x-loop
+			for x in range(-mid_x, mid_x + 1):
+				content += f"execute positioned ~{x} ~ ~ run function {ns}:custom_blocks/_player_head/search_{item}_y\n"
 			content += f"\n# Advancement\nadvancement revoke @s only {ns}:custom_block_head/{item}\n\n"
 			write_function(f"{ns}:custom_blocks/_player_head/search_{item}", content)
 
+			# Generate y-loop function
+			content_y = "# Search y coordinates\n"
+			for y in range(-mid_y, mid_y + 1):
+				content_y += f"execute positioned ~ ~{y} ~ run function {ns}:custom_blocks/_player_head/search_{item}_z\n"
+			write_function(f"{ns}:custom_blocks/_player_head/search_{item}_y", content_y)
+
+			# Generate z-loop function
+			content_z = "# Search z coordinates\n"
+			for z in range(-mid_z, mid_z + 1):
+				content_z += f"execute positioned ~ ~ ~{z} if data block ~ ~ ~ components.\"minecraft:custom_data\".{ns}.{item} run function {ns}:custom_blocks/{item}/place_main\n"
+			write_function(f"{ns}:custom_blocks/_player_head/search_{item}_z", content_z)
+

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/finalyze/dependencies/__init__.py

@@ -102,7 +102,7 @@ def beet_default(ctx: Context) -> None:
 
 	# Get all dependencies (official and custom)
 	dependencies: list[tuple[str, dict]] = [(lib_ns, data) for lib_ns, data in OFFICIAL_LIBS.items() if data["is_used"]]
-	load_dependencies: JsonDict = ctx.meta.get("load_dependencies", {})
+	load_dependencies: JsonDict = ctx.meta.get("stewbeet", {}).get("load_dependencies", {})
 	if load_dependencies:
 		dependencies += list(load_dependencies.items())
 	# Setup Lantern Load

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/ingame_manual/main.py

@@ -9,10 +9,9 @@ from beet import Font, Texture
 from beet.core.utils import JsonDict, TextComponent
 from PIL import Image
 from stouputils.collections import unique_list
-from stouputils.decorators import measure_time
 from stouputils.io import relative_path, super_json_dump, super_open
 from stouputils.parallel import colored_for_loop
-from stouputils.print import debug, error, info, suggestion, warning
+from stouputils.print import debug, error, suggestion, warning
 
 from ...core.__memory__ import Mem
 from ...core.constants import (

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/initialize/__init__.py

@@ -3,7 +3,7 @@
 import os
 from pathlib import Path
 
-from beet import Context, Pack
+from beet import Context, Pack, PngFile
 from beet.core.utils import JsonDict, TextComponent
 from box import Box
 from stouputils import relative_path
@@ -12,7 +12,7 @@ from stouputils.io import super_json_dump
 from stouputils.print import warning
 
 from ...core import Mem
-from .source_lore_font import make_source_lore_font
+from .source_lore_font import find_pack_png, make_source_lore_font
 
 
 # Main entry point
@@ -90,7 +90,12 @@ def beet_default(ctx: Context):
 				new_path = Path(textures_folder) / new_name
 				if old_path.exists() and not new_path.exists():
 					os.rename(old_path, new_path)
-					warning(f"Renamed texture {file} to {new_name}")
+					warning(f"Renamed texture '{file}' to '{new_name}'")
+
+	# Add the pack icon to the output directory for datapack and resource pack
+	pack_icon = find_pack_png()
+	if pack_icon:
+		Mem.ctx.data.extra["pack.png"] = Mem.ctx.assets.extra["pack.png"] = PngFile(source_path=pack_icon)
 
 	# Yield message to indicate successful build
 	yield

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/resource_pack/item_models/object.py

@@ -279,7 +279,9 @@ class AutoModel:
 				for texture in content["textures"].values():
 					if texture.startswith("minecraft:"):
 						continue
-					self.used_textures.add(texture)			# Copy used textures
+					self.used_textures.add(texture)
+
+			# Copy used textures
 			if content.get("textures"):
 				for texture in content["textures"].values():
 					# Ignore if minecraft namespace

{stewbeet-2.0.7 → stewbeet-2.0.8}/stewbeet/plugins/verify_definitions/__init__.py

@@ -111,18 +111,18 @@ def beet_default(ctx: Context) -> None:
 
 		# Force the use of "item_name" key for every item
 		if not data.get("item_name"):
-			errors.append(f"'item_name' key missing for '{item}', should be a dict or a list (SNBT), ex: {{\"text\":\"This is an Item Name\"}} or [\"This is an Item Name\"]")
+			errors.append(f"'item_name' key missing for '{item}', should be a Text Component, ex: {{\"text\":\"This is an Item Name\"}} or [\"This is an Item Name\"]")
 		elif not isinstance(data["item_name"], dict | list | str):
-			errors.append(f"'item_name' key should be a dict or a list (SNBT) for '{item}'")
+			errors.append(f"'item_name' key should be a Text Component for '{item}', got '{data['item_name']}'")
 
 		# Force the use of "lore" key to be in a correct format
 		if data.get("lore"):
 			if not isinstance(data["lore"], list):
-				errors.append(f"'lore' key should be a list for '{item}'")
+				errors.append(f"'lore' key should be a list for '{item}', got {data['lore']}")
 			else:
 				for i, line in enumerate(data["lore"]):
 					if not isinstance(line, dict | list | str):
-						errors.append(f"Line #{i} in 'lore' key should be a dict or a list (SNBT) for '{item}', ex: {{\"text\":\"This is a lore line\"}} or [\"This is a lore line\"]")
+						errors.append(f"Line #{i} in 'lore' key should be a Text Component for '{item}', ex: {{\"text\":\"This is a lore line\"}} or [\"This is a lore line\"]")
 					else:
 						# Verify format {"text":"..."} or "..."
 						line = str(line)
@@ -210,7 +210,7 @@ def beet_default(ctx: Context) -> None:
 
 	# Log errors if any
 	if errors:
-		error("Errors found in the definitions during verification:\n" + "\n".join(errors))
+		error("Errors found in the definitions during verification:\n- " + "\n- ".join(errors))
 	else:
 		info("No errors found in the definitions during verification")