plancraft 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

plancraft/environments/env_real.py

@@ -0,0 +1,316 @@
+from typing import Sequence, Union
+
+import numpy as np
+import json
+
+from loguru import logger
+
+from plancraft.environments.actions import RealAction
+
+try:
+    from minerl.env import _singleagent
+    from minerl.herobraine.env_specs.human_controls import HumanControlEnvSpec
+    from minerl.herobraine.hero import handlers, mc, spaces
+    from minerl.herobraine.hero.handler import Handler
+    from minerl.herobraine.hero.handlers.agent.action import Action
+    from minerl.herobraine.hero.handlers.agent.start import InventoryAgentStart
+    from minerl.herobraine.hero.handlers.translation import TranslationHandler
+
+    class InventoryCommandAction(Action):
+        """
+        Handler which lets agents programmatically interact with an open container
+
+        Using this - agents can move a chosen quantity of items from one slot to another.
+        """
+
+        def to_string(self):
+            return "inventory_command"
+
+        def xml_template(self) -> str:
+            return str("<InventoryCommands/>")
+
+        def __init__(self):
+            self._command = "inventory_command"
+            # first argument is the slot to take from
+            # second is the slot to put into
+            # third is the count to take
+            super().__init__(
+                self.command,
+                spaces.Tuple(
+                    (
+                        spaces.Discrete(46),
+                        spaces.Discrete(46),
+                        spaces.Discrete(64),
+                    )
+                ),
+            )
+
+        def from_universal(self, x):
+            return np.array([0, 0, 0], dtype=np.int32)
+
+    class SmeltCommandAction(Action):
+        """
+        An action handler for smelting an item
+        We assume smelting is immediate.
+        @TODO: might be interesting to explore using the smelting time as an additional planning parameter.
+
+        Using this agents can smelt items in their inventory.
+        """
+
+        def __init__(self):
+            self._command = "smelt"
+            # first argument is the slot to take from
+            # second is the slot to put into
+            # third is the count to smelt
+            super().__init__(
+                self.command,
+                spaces.Tuple(
+                    (
+                        spaces.Discrete(46),
+                        spaces.Discrete(46),
+                        spaces.Discrete(64),
+                    )
+                ),
+            )
+
+        def to_string(self):
+            return "smelt"
+
+        def xml_template(self) -> str:
+            return str("<SmeltCommands/>")
+
+        def from_universal(self, x):
+            return np.array([0, 0, 0], dtype=np.int32)
+
+    class InventoryResetAction(Action):
+        def __init__(self):
+            self._command = "inventory_reset"
+            super().__init__(self._command, spaces.Text([1]))
+
+        def to_string(self) -> str:
+            return "inventory_reset"
+
+        def to_hero(self, inventory_items: list[dict]):
+            return "{} {}".format(self._command, json.dumps(inventory_items))
+
+        def xml_template(self) -> str:
+            return "<InventoryResetCommands/>"
+
+        def from_universal(self, x):
+            return []
+
+    MINUTE = 20 * 60
+
+    class CustomInventoryAgentStart(InventoryAgentStart):
+        def __init__(self, inventory: list[dict[str, Union[str, int]]]):
+            super().__init__({item["slot"]: item for item in inventory})
+
+    class CraftingTableOnly(Handler):
+        def to_string(self):
+            return "start_with_crafting_table"
+
+        def xml_template(self) -> str:
+            return "<CraftingTableOnly>true</CraftingTableOnly>"
+
+    class InventoryObservation(TranslationHandler):
+        """
+        Handles GUI Workbench Observations for selected items
+        """
+
+        def to_string(self):
+            return "inventory"
+
+        def xml_template(self) -> str:
+            return str("""<ObservationFromFullInventory flat="false"/>""")
+
+        def __init__(self, item_list, _other="other"):
+            item_list = sorted(item_list)
+            super().__init__(
+                spaces.Dict(
+                    spaces={
+                        k: spaces.Box(
+                            low=0,
+                            high=2304,
+                            shape=(),
+                            dtype=np.int32,
+                            normalizer_scale="log",
+                        )
+                        for k in item_list
+                    }
+                )
+            )
+            self.num_items = len(item_list)
+            self.items = item_list
+
+        def add_to_mission_spec(self, mission_spec):
+            pass
+
+        def from_hero(self, info):
+            return info["inventory"]
+
+        def from_universal(self, obs):
+            raise NotImplementedError(
+                "from_universal not implemented in InventoryObservation"
+            )
+
+    class PlancraftBaseEnvSpec(HumanControlEnvSpec):
+        def __init__(
+            self,
+            symbolic_action_space=False,
+            symbolic_observation_space=False,
+            max_episode_steps=2 * MINUTE,
+            inventory: Sequence[dict] = (),
+            preferred_spawn_biome: str = "plains",
+            resolution=[260, 180],
+        ):
+            self.inventory = inventory
+            self.preferred_spawn_biome = preferred_spawn_biome
+            self.symbolic_action_space = symbolic_action_space
+            self.symbolic_observation_space = symbolic_observation_space
+
+            mode = "real"
+            if symbolic_action_space:
+                mode += "-symbolic-act"
+            else:
+                mode += "-real-act"
+
+            if symbolic_observation_space:
+                mode += "-symbolic-obs"
+
+            if symbolic_action_space:
+                cursor_size = 1
+            else:
+                cursor_size = 16
+
+            name = f"plancraft-{mode}-v0"
+            super().__init__(
+                name=name,
+                max_episode_steps=max_episode_steps,
+                resolution=resolution,
+                cursor_size_range=[cursor_size, cursor_size],
+            )
+
+        def create_agent_start(self) -> list[Handler]:
+            base_agent_start_handlers = super().create_agent_start()
+            return base_agent_start_handlers + [
+                CustomInventoryAgentStart(self.inventory),
+                handlers.PreferredSpawnBiome(self.preferred_spawn_biome),
+                handlers.DoneOnDeath(),
+                CraftingTableOnly(),
+            ]
+
+        def create_observables(self) -> list[TranslationHandler]:
+            if self.symbolic_observation_space:
+                return [
+                    handlers.POVObservation(self.resolution),
+                    InventoryObservation([item["slot"] for item in self.inventory]),
+                ]
+            return [handlers.POVObservation(self.resolution)]
+
+        def create_server_world_generators(self) -> list[Handler]:
+            # TODO the original biome forced is not implemented yet. Use this for now.
+            return [handlers.DefaultWorldGenerator(force_reset=True)]
+
+        def create_server_quit_producers(self) -> list[Handler]:
+            return [
+                handlers.ServerQuitFromTimeUp(
+                    (self.max_episode_steps * mc.MS_PER_STEP)
+                ),
+                handlers.ServerQuitWhenAnyAgentFinishes(),
+            ]
+
+        def create_server_initial_conditions(self) -> list[Handler]:
+            return [
+                handlers.TimeInitialCondition(allow_passage_of_time=False),
+                handlers.SpawningInitialCondition(allow_spawning=True),
+            ]
+
+        def create_actionables(self) -> list[TranslationHandler]:
+            """
+            Symbolic env can move items around in the inventory using function
+            Real env can use camera/keyboard
+            """
+            # Camera and mouse
+            if self.symbolic_action_space:
+                return [
+                    InventoryCommandAction(),
+                    SmeltCommandAction(),
+                    InventoryResetAction(),
+                ]
+            return [
+                handlers.KeybasedCommandAction(v, v) for k, v in mc.KEYMAP.items()
+            ] + [
+                handlers.CameraAction(),
+                SmeltCommandAction(),
+                InventoryResetAction(),
+            ]
+
+        def is_from_folder(self, folder: str) -> bool:
+            return False
+
+        def create_agent_handlers(self) -> list[Handler]:
+            return []
+
+        def create_mission_handlers(self):
+            return []
+
+        def create_monitors(self):
+            return []
+
+        def create_rewardables(self):
+            return []
+
+        def create_server_decorators(self) -> list[Handler]:
+            return []
+
+        def determine_success_from_rewards(self, rewards: list) -> bool:
+            return False
+
+        def get_docstring(self):
+            return self.__class__.__doc__
+
+    class RealPlancraft(_singleagent._SingleAgentEnv):
+        def __init__(
+            self,
+            inventory: list[dict],
+            preferred_spawn_biome="plains",
+            symbolic_action_space=False,
+            symbolic_observation_space=True,
+            resolution=[512, 512],
+            crop=True,
+        ):
+            # NOTE: crop is only supported for resolution 512x512 (default)
+            self.crop = crop
+            self.resolution = resolution
+            env_spec = PlancraftBaseEnvSpec(
+                symbolic_action_space=symbolic_action_space,
+                symbolic_observation_space=symbolic_observation_space,
+                preferred_spawn_biome=preferred_spawn_biome,
+                inventory=inventory,
+                resolution=resolution,
+            )
+            super(RealPlancraft, self).__init__(env_spec=env_spec)
+            self.reset()
+
+        def step(self, action: RealAction | dict):
+            if not isinstance(action, dict):
+                action = action.to_action_dict()
+            obs, rew, done, info = super().step(action)
+            if "pov" in obs and self.crop and self.resolution == [512, 512]:
+                # crop at position x=174, y=170 with width=164 and height=173
+                obs["pov"] = obs["pov"][174 : 174 + 164, 170 : 168 + 173]
+            return obs, rew, done, info
+
+        def fast_reset(self, new_inventory: list[dict]):
+            super().step({"inventory_reset": new_inventory})
+
+
+except ImportError:
+
+    class RealPlancraft:
+        def __init__(self, *args, **kwargs):
+            logger.warning(
+                "The 'minerl' package is required to use RealPlancraft. "
+                "Please install it using 'pip install plancraft[full]' or 'pip install minerl'."
+            )
+            raise ImportError("minerl package not found")

plancraft/environments/env_symbolic.py

@@ -0,0 +1,212 @@
+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
+
+
+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()

plancraft/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"]]

plancraft/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

plancraft/environments/recipes/acacia_boat.json

@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "group": "boat",
+  "pattern": [
+    "# #",
+    "###"
+  ],
+  "key": {
+    "#": {
+      "item": "minecraft:acacia_planks"
+    }
+  },
+  "result": {
+    "item": "minecraft:acacia_boat"
+  }
+}

plancraft/environments/recipes/acacia_button.json

@@ -0,0 +1,12 @@
+{
+  "type": "minecraft:crafting_shapeless",
+  "group": "wooden_button",
+  "ingredients": [
+    {
+      "item": "minecraft:acacia_planks"
+    }
+  ],
+  "result": {
+    "item": "minecraft:acacia_button"
+  }
+}

plancraft/environments/recipes/acacia_door.json

@@ -0,0 +1,18 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "group": "wooden_door",
+  "pattern": [
+    "##",
+    "##",
+    "##"
+  ],
+  "key": {
+    "#": {
+      "item": "minecraft:acacia_planks"
+    }
+  },
+  "result": {
+    "item": "minecraft:acacia_door",
+    "count": 3
+  }
+}