stewbeet 3.3.2__tar.gz → 3.4.0__tar.gz

{stewbeet-3.3.2 → stewbeet-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stewbeet
-Version: 3.3.2
+Version: 3.4.0
 Summary: Beet Framework made to help generating advanced Minecraft datapack contents
 Author: Stoupy51
 Author-email: Stoupy51 <stoupy51@gmail.com>
@@ -10,12 +10,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Dist: stouputils>=1.29.0
+Requires-Dist: stouputils>=1.29.3
 Requires-Dist: model-resolver>=1.15.2
-Requires-Dist: beet>=0.115.0
+Requires-Dist: beet>=0.116.0
 Requires-Dist: bolt>=0.50.1
-Requires-Dist: mecha>=0.103.0
-Requires-Dist: mutagen>=1.47.0
+Requires-Dist: mecha>=0.104.0
+Requires-Dist: mutagen>=1.48.1
 Requires-Dist: pyperclip>=1.11.0
 Requires-Dist: fsspec>=2026.6.0
 Requires-Dist: paramiko>=5.0.0

{stewbeet-3.3.2 → stewbeet-3.4.0}/pyproject.toml

@@ -8,7 +8,7 @@ module-root = ""
 
 [project]
 name = "stewbeet"
-version = "3.3.2"
+version = "3.4.0"
 description = "Beet Framework made to help generating advanced Minecraft datapack contents"
 readme = "README.md"
 license = "MIT"
@@ -24,12 +24,12 @@ authors = [
     { name = "Stoupy51", email = "stoupy51@gmail.com" },
 ]
 dependencies = [
-	"stouputils>=1.29.0",
+	"stouputils>=1.29.3",
 	"model_resolver>=1.15.2",
-	"beet>=0.115.0",
+	"beet>=0.116.0",
 	"bolt>=0.50.1",
-	"mecha>=0.103.0",
-	"mutagen>=1.47.0",
+	"mecha>=0.104.0",
+	"mutagen>=1.48.1",
 	"pyperclip>=1.11.0",
 	"fsspec>=2026.6.0",
 	"paramiko>=5.0.0",

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/__init__.py

@@ -8,6 +8,7 @@ from beet import *
 
 from .cli import main
 from .core import *
+from .plugins.ingame_manual.api import *
 from .plugins.initialize.source_lore_font import find_pack_png
 from .plugins.resource_pack.item_models.object import AutoModel
 from .plugins.resource_pack.sounds import add_sound

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/__init__.pyi

@@ -1,5 +1,6 @@
 from beet import *
 from .core import *
+from .plugins.ingame_manual.api import *
 from .cli import main as main
 from .plugins.initialize.source_lore_font import find_pack_png as find_pack_png
 from .plugins.resource_pack.item_models.object import AutoModel as AutoModel

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/cli.py

@@ -3,7 +3,6 @@
 import importlib
 import os
 import shutil
-import subprocess
 import sys
 
 import stouputils as stp
@@ -81,7 +80,12 @@ def main() -> None:
         stp.info("Cleaning project and caches...")
 
         # Remove the beet cache directory
-        subprocess.run([sys.executable, "-m", "beet", "cache", "-c"], check=False, capture_output=True)
+        try:
+            from beet.toolchain.project import Project
+            project = Project(resolved_config=cfg)
+            project.clear_cache([])
+        except Exception:
+            pass
         if os.path.exists(".beet_cache"):
             shutil.rmtree(".beet_cache", ignore_errors=True)
 
@@ -120,10 +124,19 @@ def main() -> None:
         def stop_callback(exception: BaseException) -> None:
             sys.exit(1)
 
-        # Try to import all pipeline
+        # Try to import all pipeline (upfront, only for nice error messages)
+        modules_before: set[str] = set(sys.modules)
         for plugin in cfg.pipeline:
             stp.handle_error(importlib.import_module, error_log=stp.LogLevels.WARNING_TRACEBACK, callback=stop_callback)(plugin)
 
+        # Forget project-local modules so beet re-imports them in its own tracked
+        # region, else `stewbeet watch` ignores edits to project source files.
+        for name in set(sys.modules) - modules_before:
+            module = sys.modules.get(name)
+            filename: str | None = getattr(module, "__file__", None)
+            if filename and "site-packages" not in filename and filename.startswith(current_dir):
+                del sys.modules[name]
+
         # Run beet with all remaining arguments
         from beet.toolchain.cli import main as beet_main
         beet_main()

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/contrib/simplenergy/cables.py

@@ -4,9 +4,10 @@
 import os
 
 import stouputils as stp
-from beet import ItemModel, Model
+from beet import ItemModel, Model, Texture
+from PIL import Image
 
-from ...core import CUSTOM_ITEM_VANILLA, Item, JsonDict, Mem, set_json_encoder, texture_mcmeta, write_function
+from ...core import Item, JsonDict, Mem, set_json_encoder, texture_mcmeta, write_advancement, write_function, write_load_file
 
 # Constants
 ENERGY_CABLE_MODELS_FOLDER: str = stp.get_root_path(__file__) + "/energy_cable_models"
@@ -81,7 +82,7 @@ tag @s add {ns}.cable
 
 	# Update_cable_model function
 	cables_str: str = "\n".join([
-		f"execute if entity @s[tag={ns}.{cable}] run item replace entity @s contents with {CUSTOM_ITEM_VANILLA}[item_model=\"{ns}:{cable}\"]"
+		f"execute if entity @s[tag={ns}.{cable}] run item replace entity @s contents with {Item.base_item}[item_model=\"{ns}:{cable}\"]"
 		for cable in cables
 	])
 	cable_update_content: str = f"""
@@ -202,7 +203,7 @@ function #itemio:calls/cables/destroy
 
 	# Update cable_model function
 	cables_str: str = "\n".join([
-		f"execute if entity @s[tag={ns}.{cable}] run item replace entity @s contents with {CUSTOM_ITEM_VANILLA}[item_model=\"{ns}:{cable}\"]"
+		f"execute if entity @s[tag={ns}.{cable}] run item replace entity @s contents with {Item.base_item}[item_model=\"{ns}:{cable}\"]"
 		for cable in cables
 	])
 	cable_update_content: str = f"""
@@ -262,14 +263,21 @@ def servo_mechanisms_models(servos: dict[str, dict[str, str] | None]) -> None:
 		connected_model["textures"] = {"0": f"{ns}:block/{connected_texture}", "particle": f"{ns}:block/{connected_texture}"}
 		Mem.ctx.assets[ns].models[f"block/servo/{typ}_connected"] = set_json_encoder(Model(connected_model), max_level=3)
 
+		# Register the off model (grayed out version of the default texture, shown when the servo is disabled)
+		off_texture: str = f"servo/{typ}_off"
+		off_model: JsonDict = stp.json_load(f"{models_path}/{typ}_block.json")
+		off_model["parent"] = f"{ns}:block/servo/base_block"
+		off_model["textures"] = {"0": f"{ns}:block/{off_texture}", "particle": f"{ns}:block/{off_texture}"}
+		Mem.ctx.assets[ns].models[f"block/servo/{typ}_off"] = set_json_encoder(Model(off_model), max_level=3)
+
 		# Register the item model
 		item_model: JsonDict = stp.json_load(f"{models_path}/{typ}_item.json")
 		item_model["parent"] = f"{ns}:block/servo/base_item"
 		item_model["textures"] = {"0": f"{ns}:block/{default_texture}", "particle": f"{ns}:block/{default_texture}"}
 		Mem.ctx.assets[ns].models[f"block/servo/{typ}_item"] = set_json_encoder(Model(item_model), max_level=3)
 
-		# Register two items file (for default and connected)
-		for texture in ("block", "connected"):
+		# Register items files (for default, connected and off)
+		for texture in ("block", "connected", "off"):
 			model_data = {
 				"model": {
 					"type": "minecraft:model",
@@ -288,6 +296,17 @@ def servo_mechanisms_models(servos: dict[str, dict[str, str] | None]) -> None:
 			if os.path.exists(src) and (not Mem.ctx.assets[ns].textures.get(dst)):
 				Mem.ctx.assets[ns].textures[dst] = texture_mcmeta(src)
 
+		# Generate the grayed out "off" texture from the default texture (desaturated and darkened)
+		off_dst: str = f"block/{off_texture}"
+		default_src: str = f"{textures_folder}/{textures.get('default', f'{typ}_default')}.png"
+		if os.path.exists(default_src) and (not Mem.ctx.assets[ns].textures.get(off_dst)):
+			with Image.open(default_src) as base_image:
+				rgba: Image.Image = base_image.convert("RGBA")
+			r, g, b, a = rgba.split()
+			gray = Image.merge("RGB", (r, g, b)).convert("L").point(lambda p: int(p * 0.5))
+			off_image: Image.Image = Image.merge("RGBA", (gray, gray, gray, a))
+			Mem.ctx.assets[ns].textures[off_dst] = Texture(off_image)
+
 		## Working functions
 		# On placement, add necessary tag and call init function
 		item = Item.from_id(servo)
@@ -301,6 +320,7 @@ tag @s add itemio.servo
 tag @s add {ns}.servo
 scoreboard players set @s itemio.servo.stack_limit {stack_limit}
 scoreboard players set @s itemio.servo.retry_limit {retry_limit}
+scoreboard players set @s {ns}.servo_off 0
 function #itemio:calls/servos/init
 """)
 		# On destruction, call destroy function of itemio
@@ -309,22 +329,117 @@ function #itemio:calls/servos/init
 function #itemio:calls/servos/destroy
 """)
 
-	# Update servo_model function
-	servo_update_content: str = f"""
+	# Update the servo model on itemio network changes (delegates to the shared model logic)
+	write_function(f"{ns}:calls/itemio/network_update", f"""
 # Stop if not {ns} servo
 execute unless entity @s[tag={ns}.custom_block,tag={ns}.servo] run return fail
 
-# Apply the model dynamically based on servo tags and itemio.math score
-"""
-	for servo, textures in servos.items():
-		if textures is None:
-			textures = {}
-		typ: str = textures.get("type", "extract")
+# Apply the model depending on the on/off state and the network connection
+function {ns}:utils/servo/update_model
+""", tags=["itemio:event/network_update"])
+
+	# Setup the "rotate to toggle on/off" feature
+	servo_toggle(servos)
+	return
+
+
+# Setup the ability to turn servos off and on by rotating (right-clicking) them
+def servo_toggle(servos: dict[str, dict[str, str] | None]) -> None:
+	""" Setup the functions allowing players to turn servo mechanisms off and on by rotating them.
+
+	Rotating (right-clicking) a servo item frame changes its 'ItemRotation'. A vanilla advancement listening to
+	the 'minecraft:player_interacted_with_entity' trigger detects the interaction (so nothing runs every tick),
+	then the nearby servos are checked: an odd rotation disables the rotated one (grayed out texture, item
+	transfers stopped by removing the 'itemio.servo.extract' / 'itemio.servo.insert' tag), an even rotation
+	enables it back to normal. As the check only acts when the parity differs, only the rotated servo toggles.
+
+	Args:
+		servos (dict[str, dict[str, str]]): Same servos dictionary as the one passed to 'servo_mechanisms_models'.
+	"""
+	ns: str = Mem.ctx.project_id
+	servo_types: dict[str, str] = {servo: (textures or {}).get("type", "extract") for servo, textures in servos.items()}
+
+	# Score holding the on/off state of each servo (created at load time)
+	write_load_file(f"\n# Score for the on/off state of servo mechanisms\nscoreboard objectives add {ns}.servo_off dummy\n")
+
+	# Advancement detecting the interaction with a servo item frame, then revoked and handled by a function
+	write_advancement(f"{ns}:technical/servo_toggle", {
+		"criteria": {
+			"requirement": {
+				"trigger": "minecraft:player_interacted_with_entity",
+				"conditions": {
+					"entity": {
+						"minecraft:entity_tags": {"any_of": [f"{ns}.servo"]},
+					},
+				},
+			},
+		},
+		"requirements": [["requirement"]],
+		"rewards": {"function": f"{ns}:utils/servo/on_interact"},
+	})
+
+	# Reward function: revoke the advancement, then check the servos around the player (only the rotated one toggles)
+	write_function(f"{ns}:utils/servo/on_interact", f"""
+# Revoke the advancement so it can trigger again
+advancement revoke @s only {ns}:technical/servo_toggle
+
+# Check the servos within reach (the change detection makes it a no-op for the ones that did not rotate)
+execute as @e[tag={ns}.servo,distance=..24] run function {ns}:utils/servo/check
+""")
+
+	# Check the rotation parity and apply the on/off state only when it changed
+	write_function(f"{ns}:utils/servo/check", f"""
+# Compute the rotation parity (0 = on, 1 = off)
+scoreboard players set #two {ns}.data 2
+execute store result score #parity {ns}.data run data get entity @s ItemRotation
+scoreboard players operation #parity {ns}.data %= #two {ns}.data
+
+# Keep the servo visually aligned while on (any even rotation is normalized to 0)
+execute if score #parity {ns}.data matches 0 unless data entity @s {{ItemRotation:0b}} run data modify entity @s ItemRotation set value 0b
+
+# Apply the state only when the parity differs from the current state
+execute if score #parity {ns}.data matches 0 unless score @s {ns}.servo_off matches 0 run function {ns}:utils/servo/enable
+execute if score #parity {ns}.data matches 1 unless score @s {ns}.servo_off matches 1 run function {ns}:utils/servo/disable
+""")
+
+	# Enable: allow item transfers again by adding back the servo tag, then restore the normal model
+	enable_tags: str = "\n".join(
+		f"execute if entity @s[tag={ns}.{servo}] run tag @s add itemio.servo.{typ}"
+		for servo, typ in servo_types.items()
+	)
+	write_function(f"{ns}:utils/servo/enable", f"""
+# Mark the servo as on and allow item transfers again
+scoreboard players set @s {ns}.servo_off 0
+{enable_tags}
+
+# Restore the normal model and play feedback
+function {ns}:utils/servo/update_model
+playsound minecraft:block.lever.click block @a[distance=..16] ~ ~ ~ 0.6 1.2
+""")
+
+	# Disable: stop item transfers by removing the servo tag, then apply the grayed out model
+	write_function(f"{ns}:utils/servo/disable", f"""
+# Mark the servo as off and stop item transfers
+scoreboard players set @s {ns}.servo_off 1
+tag @s remove itemio.servo.extract
+tag @s remove itemio.servo.insert
+
+# Apply the grayed out model and play feedback
+function {ns}:utils/servo/update_model
+playsound minecraft:block.lever.click block @a[distance=..16] ~ ~ ~ 0.6 0.7
+""")
+
+	# Shared model logic: grayed out when off, normal (depending on the network connection) when on
+	model_lines: list[str] = [
+		f'execute if score @s {ns}.servo_off matches 1 if entity @s[tag={ns}.{servo}] run data modify entity @s Item.components."minecraft:item_model" set value "{ns}:servo/{typ}_off"'
+		for servo, typ in servo_types.items()
+	]
+	for servo, typ in servo_types.items():
 		for number, texture in ((0, "block"), (1, "connected")):
-			servo_update_content += (
-				f'execute if score @s itemio.math matches {number} if entity @s[tag={ns}.{servo}] run '
-				f'data modify entity @s Item.components."minecraft:item_model" set value "{ns}:servo/{typ}_{texture}"\n'
+			model_lines.append(
+				f'execute if score @s {ns}.servo_off matches 0 if score @s itemio.math matches {number} if entity @s[tag={ns}.{servo}] run '
+				f'data modify entity @s Item.components."minecraft:item_model" set value "{ns}:servo/{typ}_{texture}"'
 			)
-	write_function(f"{ns}:calls/itemio/network_update", servo_update_content, tags=["itemio:event/network_update"])
+	write_function(f"{ns}:utils/servo/update_model", "\n".join(model_lines) + "\n")
 	return
 

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/__memory__.py

@@ -5,9 +5,9 @@
 from typing import TYPE_CHECKING
 
 from beet import Context
-from stouputils.typing import JsonDict
 
 if TYPE_CHECKING:
+    from ..plugins.ingame_manual.manual import Manual
     from .cls.external_item import ExternalItem
     from .cls.item import Item
 
@@ -18,9 +18,13 @@ class Mem:
     """ Global context object that holds the beet project configuration.
     This is set during plugins.initialize and used throughout the codebase. """
 
-    definitions: dict[str, JsonDict | Item] = {}
+    definitions: dict[str, Item] = {}
     """ JsonDict storing all item and block definitions for the project. """
 
-    external_definitions: dict[str, JsonDict | ExternalItem] = {}
+    external_definitions: dict[str, ExternalItem] = {}
     """ Secondary JsonDict for storing external items or blocks most likely for recipes. """
 
+    manual: Manual | None = None
+    """ The ingame_manual Manual handle, used to register pages/hooks during setup.
+    Created lazily via stewbeet.get_manual(); reset after each build (for `beet watch`). """
+

stewbeet-3.4.0/stewbeet/core/__memory__.pyi

@@ -0,0 +1,10 @@
+from ..plugins.ingame_manual.manual import Manual as Manual
+from .cls.external_item import ExternalItem as ExternalItem
+from .cls.item import Item as Item
+from beet import Context as Context
+
+class Mem:
+    ctx: Context
+    definitions: dict[str, Item]
+    external_definitions: dict[str, ExternalItem]
+    manual: Manual | None

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/cls/ingredients.py

@@ -137,7 +137,6 @@ class Ingr(dict[str, Any]):
 			return namespace + ":" + id
 		return id
 
-	@stp.simple_cache
 	def to_name(self) -> str:
 		""" Get the name of the ingredient, ex: "Stick" or "Adamantium Ingot" """
 		return item_id_to_name(self.to_id(add_namespace=True))

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/completion.py

@@ -7,8 +7,6 @@ from beet.core.utils import TextComponent
 from stouputils.typing import JsonDict
 
 from ..__memory__ import Mem
-from ..cls.external_item import ExternalItem
-from ..cls.item import Item
 
 
 # Add item model component
@@ -22,8 +20,7 @@ def add_item_model_component(black_list: list[str] | None = None) -> None:
 	if black_list is None:
 		black_list = []
 	for item, data in Mem.definitions.items():
-		if isinstance(data, Item):
-			data = data.components
+		data = data.components
 		if item in black_list or data.get("item_model", None) is not None:
 			continue
 		data["item_model"] = f"{Mem.ctx.project_id}:{item}"
@@ -47,8 +44,7 @@ def add_item_name_and_lore_if_missing(is_external: bool = False, black_list: lis
 	for item, data in defs.items():
 		if item in black_list:
 			continue
-		if isinstance(data, Item | ExternalItem):
-			data = data.components
+		data = data.components
 
 		# Add item name if none
 		if not data.get("item_name"):
@@ -95,8 +91,7 @@ def add_private_custom_data_for_namespace(is_external: bool = False, black_list:
 	for item, data in defs.items():
 		if item in black_list:
 			continue
-		if isinstance(data, Item | ExternalItem):
-			data = data.components
+		data = data.components
 		custom_data: JsonDict = data.setdefault("custom_data", {})
 		if is_external and ":" in item:
 			ns, id = item.split(":")
@@ -118,9 +113,7 @@ def add_smithed_ignore_vanilla_behaviours_convention() -> None:
 	Refer to https://wiki.smithed.dev/conventions/tag-specification/#custom-items for more information.
 	"""
 	for data in Mem.definitions.values():
-		if isinstance(data, Item):
-			data = data.components
-		smithed_ignore: JsonDict = data.setdefault("custom_data", {}).setdefault("smithed", {}).setdefault("ignore", {})
+		smithed_ignore: JsonDict = data.components.setdefault("custom_data", {}).setdefault("smithed", {}).setdefault("ignore", {})
 		smithed_ignore.setdefault("functionality", True)
 		smithed_ignore.setdefault("crafting", True)
 
@@ -133,8 +126,14 @@ def set_manual_components(white_list: list[str]) -> None:
 	"""
 	if not white_list:
 		return
-	from ...plugins.ingame_manual.shared_import import SharedMemory
-	SharedMemory.components_to_include = white_list
+
+	# v2 plugin (ingame_manual): record an override picked up by ManualConfig.from_meta,
+	# and update any Manual already created during setup.
+	from ...plugins.ingame_manual import config as v2_config
+	v2_config.COMPONENTS_OVERRIDE = list(white_list)
+	from ...core.__memory__ import Mem
+	if Mem.manual is not None:
+		Mem.manual.config.components_to_include = list(white_list)
 
 # Export all definitions to JSON
 def export_all_definitions_to_json(file_name: str, is_external: bool | JsonDict = False, verbose: bool = True) -> None:

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/completion.pyi

@@ -1,6 +1,4 @@
 from ..__memory__ import Mem as Mem
-from ..cls.external_item import ExternalItem as ExternalItem
-from ..cls.item import Item as Item
 from beet.core.utils import TextComponent as TextComponent
 from stouputils.typing import JsonDict as JsonDict
 

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/simplenergy.py

@@ -3,7 +3,6 @@
 from beet.core.utils import TextComponent
 
 from ..__memory__ import Mem
-from ..cls.item import Item
 
 
 def format_energy_number(number: int) -> str:
@@ -58,8 +57,7 @@ def create_energy_lore(energy_data: dict[str, int]) -> TextComponent:
 def add_energy_lore_to_definitions():
 	""" Adds energy-related lore to definitions based on their custom data. """
 	for data in Mem.definitions.values():
-		if isinstance(data, Item):
-			data = data.components
+		data = data.components
 		if "energy" in data.get("custom_data", {}):
 			data["lore"] = data.get("lore", []) + create_energy_lore(data["custom_data"]["energy"])
 

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/simplenergy.pyi

@@ -1,5 +1,4 @@
 from ..__memory__ import Mem as Mem
-from ..cls.item import Item as Item
 from beet.core.utils import TextComponent as TextComponent
 
 def format_energy_number(number: int) -> str:

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/text.py

@@ -5,13 +5,13 @@ from stouputils.typing import JsonDict
 
 
 # Functions
-def create_gradient_text(text: str, start_hex: str = "c24a17", end_hex: str = "c77e36", text_length: int | None = None) -> list[JsonDict]:
+def create_gradient_text(text: str, start_hex: str = "#c24a17", end_hex: str = "#c77e36", text_length: int | None = None) -> list[JsonDict]:
 	""" Create a gradient text effect by interpolating colors between start and end hex.
 
 	Args:
 		text        (str): The text to apply the gradient to.
-		start_hex   (str): Starting color in hex format (e.g. 'c24a17').
-		end_hex     (str): Ending color in hex format (e.g. 'c77e36').
+		start_hex   (str): Starting color in hex format (e.g. '#c24a17').
+		end_hex     (str): Ending color in hex format (e.g. '#c77e36').
 		text_length (int | None): Optional length override for the text. If provided, uses this instead of len(text).
 
 	Returns:

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/definitions_helper/text.pyi

@@ -1,12 +1,12 @@
 from stouputils.typing import JsonDict as JsonDict
 
-def create_gradient_text(text: str, start_hex: str = 'c24a17', end_hex: str = 'c77e36', text_length: int | None = None) -> list[JsonDict]:
+def create_gradient_text(text: str, start_hex: str = '#c24a17', end_hex: str = '#c77e36', text_length: int | None = None) -> list[JsonDict]:
     """ Create a gradient text effect by interpolating colors between start and end hex.
 
 \tArgs:
 \t\ttext        (str): The text to apply the gradient to.
-\t\tstart_hex   (str): Starting color in hex format (e.g. 'c24a17').
-\t\tend_hex     (str): Ending color in hex format (e.g. 'c77e36').
+\t\tstart_hex   (str): Starting color in hex format (e.g. '#c24a17').
+\t\tend_hex     (str): Ending color in hex format (e.g. '#c77e36').
 \t\ttext_length (int | None): Optional length override for the text. If provided, uses this instead of len(text).
 
 \tReturns:

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/core/utils/text_component.py

@@ -1,7 +1,5 @@
 
 # Imports
-from __future__ import annotations
-
 import stouputils as stp
 from beet.core.utils import TextComponent
 from stouputils.typing import JsonDict
@@ -47,7 +45,6 @@ def text_component_to_str(tc: TextComponent) -> str:
 			result += text_component_to_str(extra)
 	return result
 
-@stp.simple_cache
 def item_id_to_text_component(item_id: str, use_default: bool = True) -> TextComponent:
 	""" Get the TextComponent from an item id
 
@@ -99,7 +96,6 @@ def item_id_to_text_component(item_id: str, use_default: bool = True) -> TextCom
 		return id.replace("_", " ").title()
 	return ""
 
-@stp.simple_cache
 def item_id_to_name(item_id: str) -> str:
 	""" Get the name from an item id
 

{stewbeet-3.3.2 → stewbeet-3.4.0}/stewbeet/dependencies/download_manager.py

@@ -209,22 +209,16 @@ def get_lib_paths(ctx: Context) -> list[DownloadedLib]:
 	ctx.cache["stewbeet"].timeout(days=30)
 	mc_t = mc_tuple(ctx)
 	mc_v = mc_str(ctx)
-	results: list[DownloadedLib] = []
 
+	# Collect every lib to resolve first, then fetch them in parallel (network bound);
+	# results keep the input order because weld merges packs in this order.
+	tasks: list[tuple[str, JsonDict, str]] = []
 	for lib_ns, lib_data in OFFICIAL_LIBS.items():
 		if not lib_data.get("is_used", False):
 			continue
 		source = lib_data.get("source", "")
-		if source == "smithed":
-			r = resolve_smithed_lib(ctx, lib_ns, lib_data, mc_t)
-		elif source == "modrinth":
-			r = resolve_modrinth_lib(ctx, lib_ns, lib_data, mc_v)
-		elif source == "static":
-			r = resolve_static_lib(ctx, lib_ns, lib_data, mc_t, mc_v)
-		else:
-			continue
-		if r:
-			results.append(r)
+		if source in ("smithed", "modrinth", "static"):
+			tasks.append((lib_ns, lib_data, source))
 
 	# Also process custom load_dependencies entries that specify a source
 	load_deps: JsonDict = ctx.meta.get("stewbeet", {}).get("load_dependencies", {})
@@ -232,17 +226,21 @@ def get_lib_paths(ctx: Context) -> list[DownloadedLib]:
 		source = lib_data.get("source", "")
 		if not source:
 			continue  # old-format entry with explicit version — nothing to download
-		if source == "smithed":
-			r = resolve_smithed_lib(ctx, lib_ns, lib_data, mc_t)
-		elif source == "modrinth":
-			r = resolve_modrinth_lib(ctx, lib_ns, lib_data, mc_v)
-		elif source == "static":
-			r = resolve_static_lib(ctx, lib_ns, lib_data, mc_t, mc_v)
+		if source in ("smithed", "modrinth", "static"):
+			tasks.append((lib_ns, lib_data, source))
 		else:
 			stp.warning(f"Unknown source '{source}' for load_dependency '{lib_ns}'. Skipping download.")
-			continue
-		if r:
-			results.append(r)
+
+	def resolve(task: tuple[str, JsonDict, str]) -> DownloadedLib | None:
+		lib_ns, lib_data, source = task
+		if source == "smithed":
+			return resolve_smithed_lib(ctx, lib_ns, lib_data, mc_t)
+		if source == "modrinth":
+			return resolve_modrinth_lib(ctx, lib_ns, lib_data, mc_v)
+		return resolve_static_lib(ctx, lib_ns, lib_data, mc_t, mc_v)
+
+	resolved: list[DownloadedLib | None] = stp.multithreading(resolve, tasks, max_workers=min(8, len(tasks))) if tasks else []
+	results: list[DownloadedLib] = [r for r in resolved if r]
 
 	BUILD_CACHE[cache_key] = results
 	return results