plancraft 0.1.0__py3-none-any.whl

environments/env_symbolic.py

@@ -0,0 +1,215 @@
+import logging
+from typing import Optional
+
+from plancraft.environments.actions import SymbolicAction
+from plancraft.environments.recipes import (
+    RECIPES,
+    ShapedRecipe,
+    ShapelessRecipe,
+    SmeltingRecipe,
+    convert_ingredients_to_table,
+)
+from plancraft.environments.sampler import MAX_STACK_SIZE
+
+logger = logging.getLogger(__name__)
+
+
+class PseudoActionSpace:
+    def no_op(self):
+        return {
+            "inventory_command": (0, 0, 0),
+        }
+
+
+class SymbolicPlancraft:
+    def __init__(self, inventory: list[dict] = [], recipes=RECIPES, **kwargs):
+        self.inventory = inventory
+        self.reset_state()
+        self.table_indexes = list(range(1, 10))
+        self.output_index = 0
+
+        self.action_space = PseudoActionSpace()
+
+        self.recipes = recipes
+
+        self.smelting_recipes = []
+
+        self.crafting_recipes = []
+
+        for recipe_list in recipes.values():
+            for recipe in recipe_list:
+                if isinstance(recipe, SmeltingRecipe):
+                    self.smelting_recipes.append(recipe)
+                elif isinstance(recipe, (ShapelessRecipe, ShapedRecipe)):
+                    self.crafting_recipes.append(recipe)
+
+    def reset_state(self):
+        self.state = {i: {"type": "air", "quantity": 0} for i in range(46)}
+        # initialise inventory
+        for item in self.inventory:
+            self.state[item["slot"]] = {
+                "type": item["type"],
+                "quantity": item["quantity"],
+            }
+
+    def step(self, action: Optional[SymbolicAction | dict]):
+        if action is None:
+            state_list = [
+                {"type": item["type"], "quantity": item["quantity"], "index": idx}
+                for idx, item in self.state.items()
+            ]
+            return {"inventory": state_list}, 0, False, {}
+
+        # action_dict = action.to_action_dict()
+        if not isinstance(action, dict):
+            action = action.to_action_dict()
+
+        if "inventory_command" in action:
+            # do inventory command (move)
+            slot, slot_to, quantity = action["inventory_command"]
+            self.move_item(slot, slot_to, quantity)
+        elif "smelt" in action:
+            # do smelt
+            slot, slot_to, quantity = action["smelt"]
+            self.smelt_item(slot, slot_to, quantity)
+        else:
+            raise ValueError("Invalid action")
+            # logger.warn("Cannot parse action for Symbolic action")
+
+        self.clean_state()
+
+        # convert to list for same format as minerl
+        state_list = [
+            {"type": item["type"], "quantity": item["quantity"], "index": idx}
+            for idx, item in self.state.items()
+        ]
+
+        return {"inventory": state_list}, 0, False, {}
+
+    def clean_state(self):
+        # reset slot type if quantity is 0
+        for i in self.state.keys():
+            if self.state[i]["quantity"] == 0:
+                self.state[i]["type"] = "air"
+
+    def move_item(self, slot_from: int, slot_to: int, quantity: int):
+        if slot_from == slot_to or quantity < 1 or slot_to == 0:
+            return
+        # slot outside of inventory
+        if slot_from not in self.state or slot_to not in self.state:
+            return
+        # not enough
+        if self.state[slot_from]["quantity"] < quantity:
+            return
+
+        item = self.state[slot_from]
+
+        # slot to is not empty or is the same type as item
+        if (self.state[slot_to]["type"] == "air") or (
+            self.state[slot_to]["quantity"] <= 0
+        ):
+            self.state[slot_to] = {"type": item["type"], "quantity": quantity}
+            self.state[slot_from]["quantity"] -= quantity
+        elif self.state[slot_to]["type"] == item["type"] and (
+            MAX_STACK_SIZE[item["type"]] >= self.state[slot_to]["quantity"] + quantity
+        ):
+            # check if the quantity exceeds the max stack size
+            self.state[slot_to]["quantity"] += quantity
+            self.state[slot_from]["quantity"] -= quantity
+        else:
+            return
+
+        # reset slot if quantity is 0
+        if self.state[slot_from]["quantity"] == 0:
+            self.state[slot_from] = {"type": "air", "quantity": 0}
+
+        # use up ingredients
+        if slot_from == 0:
+            self.use_ingredients()
+
+        # populate craft slot if ingredients in crafting table have changed
+        if slot_to < 10 or slot_from < 10:
+            self.populate_craft_slot_craft_item()
+
+    def smelt_item(self, slot_from: int, slot_to: int, quantity: int):
+        if quantity < 1 or slot_to == 0 or slot_from == slot_to or slot_from == 0:
+            return  # skip if quantity is less than 1
+
+        if slot_from not in self.state or slot_to not in self.state:
+            return  # handle slot out of bounds or invalid slot numbers
+
+        item = self.state[slot_from]
+        if item["quantity"] < quantity or item["type"] == "air":
+            return  # skip if the slot from is empty or does not have enough items
+
+        for recipe in self.smelting_recipes:
+            if output := recipe.smelt(item["type"]):
+                output_type = output.item
+                # Check if the destination slot is empty or has the same type of item as the output
+                if self.state[slot_to]["type"] == "air":
+                    self.state[slot_to] = {"type": output_type, "quantity": quantity}
+                    self.state[slot_from]["quantity"] -= quantity
+                    break
+                elif self.state[slot_to]["type"] == output_type and (
+                    MAX_STACK_SIZE[output_type]
+                    >= self.state[slot_to]["quantity"] + quantity
+                ):  # assuming max stack size is 64
+                    self.state[slot_to]["quantity"] += quantity
+                    self.state[slot_from]["quantity"] -= quantity
+                    break
+                else:
+                    return  # No space or type mismatch in slot_to
+
+        # Clean up if the source slot is depleted
+        if self.state[slot_from] == 0:
+            self.state[slot_from] = {"type": "air", "quantity": 0}
+
+        if slot_to < 10 or slot_from < 10:
+            self.populate_craft_slot_craft_item()
+
+    def populate_craft_slot_craft_item(self):
+        # get ingredients from crafting table
+        ingredients = []
+        for i in self.table_indexes:
+            if self.state[i]["type"] != "air" and self.state[i]["quantity"] > 0:
+                ingredients.append(self.state[i]["type"])
+            else:
+                ingredients.append(None)
+        table = convert_ingredients_to_table(ingredients)
+
+        # check if any of the crafting recipes match the ingredients
+        for recipe in self.crafting_recipes:
+            if result := recipe.craft(table):
+                result, indexes = result
+                self.ingredients_idxs = indexes
+                self.state[self.output_index] = {
+                    "type": result.item,
+                    "quantity": result.count,
+                }
+                return
+
+        self.ingredients_idxs = []
+        self.state[self.output_index] = {"type": "air", "quantity": 0}
+
+    def use_ingredients(self):
+        # remove used ingredients from crafting table
+        for idx in self.ingredients_idxs:
+            self.state[idx + 1]["quantity"] -= 1
+            if self.state[idx + 1]["quantity"] <= 0:
+                self.state[idx + 1] = {"type": "air", "quantity": 0}
+        self.ingredients_idxs = []
+
+    def reset(self):
+        self.reset_state()
+        return self.state
+
+    def fast_reset(self, new_inventory: list[dict]):
+        self.inventory = new_inventory
+        self.reset_state()
+        return self.state
+
+    def render(self):
+        print(f"state: {self.state}")
+
+    def close(self):
+        self.reset_state()

environments/items.py

@@ -0,0 +1,10 @@
+import json
+import os
+
+
+# originally mc_constants.1.16.json
+path = os.path.join(os.path.dirname(__file__), "constants.json")
+all_data = json.load(open(path))
+
+
+ALL_ITEMS = [item["type"] for item in all_data["items"]]

environments/planner.py

@@ -0,0 +1,109 @@
+import time
+
+import networkx as nx
+
+from plancraft.environments.recipes import RECIPES, BaseRecipe
+
+RECIPE_GRAPH = nx.DiGraph()
+
+for item, recipes in RECIPES.items():
+    for recipe in recipes:
+        RECIPE_GRAPH.add_node(recipe.result.item)
+        for ingredient in recipe.inputs:
+            RECIPE_GRAPH.add_node(ingredient)
+            RECIPE_GRAPH.add_edge(ingredient, recipe.result.item)
+
+
+def get_ancestors(target: str):
+    return list(nx.ancestors(RECIPE_GRAPH, source=target))
+
+
+def optimal_planner(
+    target: str,
+    inventory: dict[str, int],
+    steps=[],
+    best_steps=None,
+    max_steps=40,
+    timeout=30,
+) -> list[tuple[BaseRecipe, dict[str, int]]]:
+    """
+    Optimal planner for crafting the target item from the given inventory.
+
+    Uses depth-first search with memoization to find the shortest path of crafting steps.
+
+    Args:
+        target: The target item to craft.
+        inventory: The current inventory.
+        steps: The current path of crafting steps.
+        best_steps: The best path of crafting steps found so far.
+        max_steps: The maximum number of steps to take.
+        timeout: The maximum time to spend searching for a solution.
+
+    Returns:
+        list of tuples of (recipe, inventory) for each step in the optimal path.
+    """
+
+    memo = {}
+    # only look at recipes that are ancestors of the target
+    ancestors = get_ancestors(target)
+    # sort to put the closest ancestors first
+    ancestors = sorted(
+        ancestors,
+        key=lambda x: nx.shortest_path_length(RECIPE_GRAPH, source=x, target=target),
+    )
+
+    time_now = time.time()
+
+    def dfs(starting_inventory, steps, best_steps):
+        # If we have exceeded the timeout, return the best known path so far.
+        if time.time() - time_now > timeout:
+            raise TimeoutError("Timeout exceeded")
+
+        memo_key = (frozenset(starting_inventory.items()), len(steps))
+        if memo_key in memo:
+            return memo[memo_key]
+
+        if best_steps is not None and len(steps) >= len(best_steps):
+            # If we already have a shorter or equally short solution, do not proceed further.
+            return best_steps
+
+        if len(steps) > max_steps:
+            # If we have already exceeded the maximum number of steps, do not proceed further.
+            return best_steps
+
+        if target in starting_inventory and starting_inventory[target] > 0:
+            # If the target item is already in the inventory in the required amount, return the current path.
+            if best_steps is None or len(steps) < len(best_steps):
+                return steps
+            return best_steps
+
+        for recipe_name in [target] + ancestors:
+            # skip if already have 9 of the item
+            if starting_inventory.get(recipe_name, 0) >= 9:
+                continue
+            # TODO prevent looping between equivalent recipes (coal <-> coal_block)
+            for recipe in RECIPES[recipe_name]:
+                if recipe.can_craft_from_inventory(starting_inventory):
+                    # Craft this item and update the inventory.
+                    new_inventory = recipe.craft_from_inventory(starting_inventory)
+                    # Add this step to the path.
+                    new_steps = steps + [(recipe, new_inventory)]
+
+                    # Recursively try to craft the target item with the updated inventory.
+                    candidate_steps = dfs(new_inventory, new_steps, best_steps)
+
+                    # Update the best known path if the candidate path is better.
+                    if candidate_steps is not None and (
+                        best_steps is None or len(candidate_steps) < len(best_steps)
+                    ):
+                        best_steps = candidate_steps
+
+        memo[memo_key] = best_steps
+        return best_steps
+
+    try:
+        path = dfs(inventory, steps, best_steps)
+        return path
+
+    except TimeoutError:
+        return None