stewbeet 2.1.1__tar.gz → 2.1.2__tar.gz

{stewbeet-2.1.1 → stewbeet-2.1.2}/PKG-INFO

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

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

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/__init__.py

@@ -0,0 +1,31 @@
+
+# Imports
+from typing import Any
+
+from beet import Context
+from stouputils.decorators import measure_time
+from stouputils.print import progress
+
+from .constants import SorterFile
+from .match import generate_sorter
+
+
+# Main entry point
+@measure_time(progress, message="Execution time of 'stewbeet.plugins.datapack.sorters'")
+def beet_default(ctx: Context):
+	""" Main entry point for the sorters plugin.
+	This plugin generates functions that sort lists in storage.
+
+	Args:
+		ctx (Context): The beet context.
+	"""
+	ctx.data.extend_namespace.append(SorterFile)
+
+	# Iterate through all sorter configurations
+	for file_instance in ctx.data[SorterFile].values():
+		sorter: dict[str, Any] = file_instance.data.dict()
+		generate_sorter(ctx, sorter)
+
+	# Clear the registry
+	ctx.data[SorterFile].clear()
+

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/constants.py

@@ -0,0 +1,63 @@
+
+# Imports
+from typing import Any, ClassVar, Literal, TypeAlias
+
+from beet import FileDeserialize, JsonFileBase, NamespaceFileScope
+from pydantic.v1 import BaseModel
+
+# Constants
+MACRO: str = "storage sorter:temp args"
+
+# Type aliases
+SorterAlgorithm: TypeAlias = Literal[
+	"quick_sort",
+	"selection_sort"
+]
+
+# Classes
+class Sorter(BaseModel):
+	""" Configuration model for sorting operations.
+
+	This class defines the parameters required to generate datapack functions
+	that can sort lists stored in storage using various algorithms.
+
+	Example:
+	```
+		{
+			"algorithm": "selection_sort",
+			"functions_location": "switch:stats/minigame/sort_leaderboard",
+			"to_sort": {
+				"storage": "switch:stats",
+				"target": "all.modes.sheepwars.played"
+			},
+			"key": "count",
+			"scale": 100
+		}
+	```
+	"""
+	algorithm: SorterAlgorithm = "selection_sort"
+	""" Algorithm used to sort the elements, defaults to `selection_sort`. """
+	functions_location: str
+	""" Namespaced id where the sorting functions are generated. """
+	to_sort: dict[str, str]
+	""" Location of the list to sort. """
+	key: str
+	""" The key to the number getting compared. """
+	scale: int = 1
+	""" (Option) By how many the number should be scaled before getting rounded. """
+	limit: int | None = None
+	""" (Option) Limit of how many elements to sort, if not specified all elements will be sorted.
+	(Only compatible with `selection_sort` algorithm.) """
+
+
+class SorterFile(JsonFileBase[Sorter]):
+	""" JSON file handler for sorter configurations.
+
+	This class handles the serialization and deserialization of sorter
+	configuration files within the datapack namespace.
+	"""
+	model: type[Any] = Sorter
+	scope: ClassVar[NamespaceFileScope] = ("sorter",)
+	extension: ClassVar[str] = ".json"
+	data: ClassVar[FileDeserialize[Sorter]] = FileDeserialize()
+

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/extend_datapack.py

@@ -0,0 +1,19 @@
+
+# Imports
+from beet import Context
+
+from .constants import SorterFile
+
+
+# Main entry point
+def beet_default(ctx: Context):
+	""" Extend the datapack namespace with the sorter resource type.
+
+	This function registers the SorterFile class with the datapack context,
+	allowing sorter configuration files to be recognized and processed.
+
+	Args:
+		ctx (Context): The beet context.
+	"""
+	ctx.data.extend_namespace.append(SorterFile)
+

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/match.py

@@ -0,0 +1,33 @@
+
+# Imports
+from beet import Context
+
+from .quick_sort import generate_quick_sort
+from .selection_sort import generate_selection_sort
+
+
+# Functions
+def generate_sorter(ctx: Context, sorter: dict):
+	""" Generate sorting functions based on the specified algorithm.
+
+	Currently an abstraction layer in case more algorithms are added in the future.
+	Routes to the appropriate algorithm-specific generator function.
+
+	Args:
+		ctx (Context): The beet context for generating functions.
+		sorter (dict): Configuration dictionary containing sorting parameters.
+	"""
+	# Assertions to validate sorter configuration
+	assert isinstance(sorter.get("functions_location"), str), "'functions_location' must be a string, e.g. 'switch:stats/minigame/sort_leaderboard'."
+	assert isinstance(sorter.get("key"), str), "'key' must be a string, e.g. 'count' if you list is looking like [{'id':'...', count:54}, ...]."
+	assert isinstance(sorter.get("to_sort"), dict), "'to_sort' must be a dictionary."
+	assert isinstance(sorter["to_sort"].get("storage"), str), "'to_sort.storage' must be a string, e.g. 'switch:stats'"
+	assert isinstance(sorter["to_sort"].get("target"), str), "'to_sort.target' must be a string, e.g. 'all.modes.sheepwars.played'."
+
+	# Switch case
+	match(sorter["algorithm"]):
+		case "selection_sort":
+			generate_selection_sort(ctx, sorter)
+		case "quick_sort":
+			generate_quick_sort(ctx, sorter)
+

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/quick_sort.py

@@ -0,0 +1,102 @@
+""" Quick Sort Algorithm for Minecraft Storage Lists
+
+This algorithm is less efficient than the Selection Sort algorithm for Minecraft due to the cost of macro calls.
+It is recommended to use Selection Sort.
+
+Author: Darukshock
+"""
+
+# Imports
+from beet import Context
+
+from ....core import Mem, write_function
+from .constants import MACRO
+
+
+# Functions
+def generate_quick_sort(ctx: Context, sorter: dict) -> None:
+	""" Generate quick_sort algorithm functions for sorting storage lists.
+
+	This function creates a set of minecraft functions that implement the quick_sort
+	algorithm to sort lists stored in minecraft storage. The algorithm is implemented
+	using recursive function calls with macro parameters.
+
+	Args:
+		ctx (Context): The beet context for generating functions.
+		sorter (dict): Configuration dictionary containing sorting parameters.
+	"""
+	old_ctx: Context = Mem.ctx
+	Mem.ctx = ctx  # Set the current context to the one provided
+
+	# Extract configuration parameters
+	functions_location: str = sorter["functions_location"]
+	to_sort: str = f"storage {sorter['to_sort']['storage']} {sorter['to_sort']['target']}"
+	key: str = sorter["key"]
+	scale: int = sorter.get("scale", 1)  # Default scale is 1
+
+	# Main sort entry point function
+	write_function(f"{functions_location}/sort", f"""
+# Create a scoreboard objective and storage for temporary values
+scoreboard objectives add sorter.val dummy
+data modify storage sorter:temp inInt set value [0]
+
+# Count the number of elements to sort and prepare the macro
+execute store result score high sorter.val run data get {to_sort}
+execute store result {MACRO}.high int 1 run scoreboard players remove high sorter.val 1
+data modify {MACRO}.low set value 0
+
+# Start the quick_sort process
+function {functions_location}/quick_sort with {MACRO}
+""")
+
+	# Quicksort recursive function
+	write_function(f"{functions_location}/quick_sort", f"""
+$execute if predicate {{"condition": "value_check","range": {{"min": -8,"max": $(low)}},"value": $(high)}} run return 0
+$execute store result score pi sorter.val run function {functions_location}/partition_main {{low:$(low),high:$(high)}}
+data modify storage sorter:temp inInt append value 0
+execute store result storage sorter:temp inInt[-1] int 1 store result {MACRO}.high int 1 run scoreboard players remove pi sorter.val 1
+function {functions_location}/quick_sort with {MACRO}
+execute store result score pi sorter.val run data get storage sorter:temp inInt[-1]
+execute store result {MACRO}.low int 1 run scoreboard players add pi sorter.val 2
+$data modify {MACRO}.high set value $(high)
+function {functions_location}/quick_sort with {MACRO}
+""")
+
+	# Partition function - finds pivot position
+	write_function(f"{functions_location}/partition_main", f"""
+$execute store result score pivot sorter.val run data get {to_sort}[$(high)].{key} {scale}
+$scoreboard players set i sorter.val $(low)
+scoreboard players remove i sorter.val 1
+$execute store result {MACRO}.j int 1 run scoreboard players set j sorter.val $(low)
+$function {functions_location}/partition_loop {{high:$(high),low:$(low),j:$(low)}}
+execute store result {MACRO}.i int 1 run scoreboard players add i sorter.val 1
+$data modify {MACRO}.j set value $(high)
+function {functions_location}/partition_swap with {MACRO}
+return run scoreboard players get i sorter.val
+""")
+
+	# Partition loop - iterates through elements to partition
+	write_function(f"{functions_location}/partition_loop", f"""
+$execute if score j sorter.val matches $(high).. run return 0
+$execute store result score test sorter.val run data get {to_sort}[$(j)].{key} {scale}
+execute if score test sorter.val < pivot sorter.val run function {functions_location}/partition_loop_swap with {MACRO}
+execute store result {MACRO}.j int 1 run scoreboard players add j sorter.val 1
+function {functions_location}/partition_loop with {MACRO}
+""")
+
+	# Partition swap - swaps elements during partitioning
+	write_function(f"{functions_location}/partition_swap", f"""
+$data modify storage sorter:temp element set from {to_sort}[$(i)]
+$data modify {to_sort}[$(i)] set from {to_sort}[$(j)]
+$data modify {to_sort}[$(j)] set from storage sorter:temp element
+""")
+
+	# Partition loop swap - continues partitioning after swap
+	write_function(f"{functions_location}/partition_loop_swap", f"""
+execute store result {MACRO}.i int 1 run scoreboard players add i sorter.val 1
+function {functions_location}/partition_swap with {MACRO}
+""")
+
+	# Reset the context to the original one
+	Mem.ctx = old_ctx
+

stewbeet-2.1.2/stewbeet/plugins/datapack/sorters/selection_sort.py

@@ -0,0 +1,124 @@
+
+# Imports
+from beet import Context
+
+from ....core import Mem, write_function
+from .constants import MACRO
+
+
+# Functions
+def generate_selection_sort(ctx: Context, sorter: dict) -> None:
+	""" Generate selection sort algorithm functions for sorting storage lists.
+
+	This function creates a set of minecraft functions that implement the selection sort
+	algorithm to sort lists stored in minecraft storage. The algorithm finds the minimum
+	element and moves it to a new sorted array repeatedly.
+
+	Args:
+		ctx (Context): The beet context for generating functions.
+		sorter (dict): Configuration dictionary containing sorting parameters.
+	"""
+	old_ctx: Context = Mem.ctx
+	Mem.ctx = ctx  # Set the current context to the one provided
+
+	# Extract configuration parameters
+	functions_location: str = sorter["functions_location"]
+	to_sort: str = f"storage {sorter['to_sort']['storage']} {sorter['to_sort']['target']}"
+	key: str = sorter["key"]
+	scale: int = sorter.get("scale", 1)  # Default scale is 1
+	limit: int | None = sorter.get("limit")  # Optional limit for sorting
+
+	# Main sort entry point function
+	sort_function_content = f"""
+# Create a scoreboard objective and storage for temporary values
+scoreboard objectives add sorter.val dummy
+data modify storage sorter:temp original_array set from {to_sort}
+data modify storage sorter:temp sorted_array set value []
+"""
+	if limit is not None:
+		sort_function_content += """
+scoreboard players set #sorted_count sorter.val 0
+"""
+	sort_function_content += f"""
+# Start the selection sort process
+execute if data storage sorter:temp original_array[0] run function {functions_location}/selection_sort_loop
+data modify {to_sort} set from storage sorter:temp sorted_array
+
+# Cleanup temporary storage
+data remove storage sorter:temp original_array
+data remove storage sorter:temp copy_array
+data remove storage sorter:temp sorted_array
+"""
+	write_function(f"{functions_location}/sort", sort_function_content)
+
+	# Selection sort main loop
+	loop_function_content = f"""
+# Reset variables for finding minimum
+scoreboard players set #current_index sorter.val 0
+scoreboard players set #min_value sorter.val 2147483647
+scoreboard players set #min_index sorter.val 0
+
+# Copy the original array to the working copy
+data modify storage sorter:temp copy_array set from storage sorter:temp original_array
+
+# Find the minimum element
+execute if data storage sorter:temp copy_array[0] run function {functions_location}/find_min
+
+# Move the minimum element to the sorted array
+execute store result {MACRO}.min_index int 1 run scoreboard players get #min_index sorter.val
+function {functions_location}/move_min_element with {MACRO}
+"""
+	if limit is not None:
+		loop_function_content += f"""
+# Increment sorted count
+scoreboard players add #sorted_count sorter.val 1
+
+# Continue if limit not reached and there are more elements to sort
+execute if score #sorted_count sorter.val matches ..{limit-1} if data storage sorter:temp original_array[0] run return run function {functions_location}/selection_sort_loop
+
+# If limit reached, append remaining elements without sorting
+execute if score #sorted_count sorter.val matches {limit} run function {functions_location}/append_remaining
+"""
+	else:
+		loop_function_content += f"""
+# Continue if there are more elements to sort
+execute if data storage sorter:temp original_array[0] run function {functions_location}/selection_sort_loop
+"""
+	write_function(f"{functions_location}/selection_sort_loop", loop_function_content)
+
+	# Find minimum element in the array
+	write_function(f"{functions_location}/find_min", f"""
+# Get the current element value
+execute store result score #current_value sorter.val run data get storage sorter:temp copy_array[0].{key} {scale}
+
+# Check if this is the new minimum
+execute if score #current_value sorter.val < #min_value sorter.val run scoreboard players operation #min_index sorter.val = #current_index sorter.val
+execute if score #current_value sorter.val < #min_value sorter.val run scoreboard players operation #min_value sorter.val = #current_value sorter.val
+
+# Move to the next element
+scoreboard players add #current_index sorter.val 1
+data remove storage sorter:temp copy_array[0]
+
+# Continue if there are more elements
+execute if data storage sorter:temp copy_array[0] run function {functions_location}/find_min
+""")
+
+	# Move the minimum element from original to sorted array
+	write_function(f"{functions_location}/move_min_element", """
+# Add the minimum element to the sorted array
+$data modify storage sorter:temp sorted_array append from storage sorter:temp original_array[$(min_index)]
+
+# Remove the minimum element from the original array
+$data remove storage sorter:temp original_array[$(min_index)]
+""")
+
+	# Generate append_remaining function only if limit is specified
+	if limit is not None:
+		write_function(f"{functions_location}/append_remaining", """
+# Append remaining unsorted elements to the sorted array
+data modify storage sorter:temp sorted_array append from storage sorter:temp original_array[]
+""")
+
+	# Reset the context to the original one
+	Mem.ctx = old_ctx
+

{stewbeet-2.1.1 → stewbeet-2.1.2}/stewbeet/plugins/initialize/__init__.py

@@ -106,6 +106,9 @@ def beet_default(ctx: Context):
 		(1, 21, 8): 64,
 	})
 
+	# Extend the datapack namespace with sorter files
+	ctx.require("stewbeet.plugins.datapack.sorters.extend_datapack")
+
 	# Yield message to indicate successful build
 	yield