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

environments/env_symbolic.py

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

environments/items.py

@@ -1,10 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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