plancraft 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

plancraft/environment/__init__.py

@@ -0,0 +1,21 @@
+from .actions import (
+    ImpossibleActionHandler,
+    MoveActionHandler,
+    SmeltActionHandler,
+    ThinkActionHandler,
+    convert_from_slot_index,
+    convert_to_slot_index,
+)
+from .env import PlancraftEnvironment
+from .search import GoldSearchActionHandler
+
+__all__ = [
+    "ImpossibleActionHandler",
+    "MoveActionHandler",
+    "SmeltActionHandler",
+    "ThinkActionHandler",
+    "PlancraftEnvironment",
+    "GoldSearchActionHandler",
+    "convert_from_slot_index",
+    "convert_to_slot_index",
+]

plancraft/environment/actions.py

@@ -0,0 +1,306 @@
+import abc
+import re
+from typing import Optional
+
+from pydantic import BaseModel, field_validator, model_validator
+
+
+def convert_to_slot_index(slot: str) -> int:
+    slot = slot.strip()
+    grid_map = {
+        "[0]": 0,
+        "[A1]": 1,
+        "[A2]": 2,
+        "[A3]": 3,
+        "[B1]": 4,
+        "[B2]": 5,
+        "[B3]": 6,
+        "[C1]": 7,
+        "[C2]": 8,
+        "[C3]": 9,
+    }
+    if slot in grid_map:
+        return grid_map[slot]
+    else:
+        return int(slot[2:-1]) + 9
+
+
+def convert_from_slot_index(slot_index: int) -> str:
+    grid_map = {
+        0: "[0]",
+        1: "[A1]",
+        2: "[A2]",
+        3: "[A3]",
+        4: "[B1]",
+        5: "[B2]",
+        6: "[B3]",
+        7: "[C1]",
+        8: "[C2]",
+        9: "[C3]",
+    }
+    if slot_index < 10:
+        return grid_map[slot_index]
+    else:
+        return f"[I{slot_index-9}]"
+
+
+class ActionHandlerBase(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def prompt_description(self) -> str:
+        """
+        Return the prompt description for the model
+        """
+        raise NotImplementedError()
+
+    @property
+    @abc.abstractmethod
+    def prompt_format_example(self) -> str:
+        """
+        Return the prompt format example for the model
+        """
+        raise NotImplementedError()
+
+    @property
+    @abc.abstractmethod
+    def action_name(self) -> str:
+        """
+        Return the action name for the model
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def match(self, generated_text: str):
+        """
+        Match the generated text to the action/tool
+        """
+        raise NotImplementedError()
+
+
+class MoveAction(BaseModel):
+    """ "Moves an item from one slot to another"""
+
+    slot_from: int
+    slot_to: int
+    quantity: int
+    action_type: str = "move"
+
+    @field_validator("action_type", mode="before")
+    def fix_action_type(cls, value) -> str:
+        return "move"
+
+    @field_validator("slot_from", "slot_to", mode="before")
+    def transform_str_to_int(cls, value) -> int:
+        # if value is a string like [A1] or [I1], convert it to an integer
+        if isinstance(value, str):
+            try:
+                return convert_to_slot_index(value)
+            except ValueError:
+                raise AttributeError(
+                    "slot_from and slot_to must be [0] or [A1] to [C3] or [I1] to [I36]"
+                )
+        return value
+
+    @field_validator("quantity", mode="before")
+    def transform_quantity(cls, value) -> int:
+        if isinstance(value, str):
+            try:
+                return int(value)
+            except ValueError:
+                raise AttributeError("quantity must be an integer")
+        return value
+
+    @model_validator(mode="after")
+    def validate(self):
+        if self.slot_from == self.slot_to:
+            raise AttributeError("slot_from and slot_to must be different")
+        if self.slot_from < 0 or self.slot_from > 45:
+            raise AttributeError("slot_from must be between 0 and 45")
+        if self.slot_to < 1 or self.slot_to > 45:
+            raise AttributeError("slot_to must be between 1 and 45")
+        if self.quantity < 1 or self.quantity > 64:
+            raise AttributeError("quantity must be between 1 and 64")
+        return self
+
+    def __str__(self):
+        return f"move: from {convert_from_slot_index(self.slot_from)} to {convert_from_slot_index(self.slot_to)} with quantity {self.quantity}"
+
+
+class SmeltAction(BaseModel):
+    """Smelts an item and moves the result into a new slot"""
+
+    slot_from: int
+    slot_to: int
+    quantity: int
+    action_type: str = "smelt"
+
+    @field_validator("action_type", mode="before")
+    def fix_action_type(cls, value) -> str:
+        return "smelt"
+
+    @field_validator("slot_from", "slot_to", mode="before")
+    def transform_str_to_int(cls, value) -> int:
+        # if value is a string like [A1] or [I1], convert it to an integer
+        if isinstance(value, str):
+            try:
+                return convert_to_slot_index(value)
+            except ValueError:
+                raise AttributeError(
+                    "slot_from and slot_to must be [0] or [A1] to [C3] or [I1] to [I36]"
+                )
+        return value
+
+    @field_validator("quantity", mode="before")
+    def transform_quantity(cls, value) -> int:
+        if isinstance(value, str):
+            try:
+                return int(value)
+            except ValueError:
+                raise AttributeError("quantity must be an integer")
+        return value
+
+    @model_validator(mode="after")
+    def validate(self):
+        if self.slot_from == self.slot_to:
+            raise AttributeError("slot_from and slot_to must be different")
+        if self.slot_from < 0 or self.slot_from > 45:
+            raise AttributeError("slot_from must be between 0 and 45")
+        if self.slot_to < 1 or self.slot_to > 45:
+            raise AttributeError("slot_to must be between 1 and 45")
+        if self.quantity < 1 or self.quantity > 64:
+            raise AttributeError("quantity must be between 1 and 64")
+        return self
+
+    def __str__(self):
+        return f"smelt: from {convert_from_slot_index(self.slot_from)} to {convert_from_slot_index(self.slot_to)} with quantity {self.quantity}"
+
+
+class StopAction(BaseModel):
+    """
+    Action that model can take to stop planning - decide impossible to continue
+    Note: also known as the "impossible" action
+    """
+
+    reason: str = ""
+
+    def __str__(self):
+        return f"impossible: {self.reason}"
+
+
+# when symbolic action is true, can either move objects around or smelt
+SymbolicAction = MoveAction | SmeltAction
+
+
+class MoveActionHandler(ActionHandlerBase):
+    @property
+    def prompt_description(self) -> str:
+        return "Transfer a specific quantity of an item from one slot to another"
+
+    @property
+    def prompt_format_example(self) -> str:
+        return "`move: from [Source] to [Target] with quantity N`"
+
+    @property
+    def action_name(self) -> str:
+        return "move"
+
+    def match(self, generated_text: str) -> Optional[MoveAction | str]:
+        """
+        Parse the raw model response to a MoveAction
+        """
+        action_match = re.search(f"({self.action_name}):", generated_text)
+        if not action_match:
+            return
+        try:
+            slot_from = re.search(r" from (\[[ABCI]?\d+\])", generated_text).group(1)
+            slot_to = re.search(r" to (\[[ABCI]?\d+\])", generated_text).group(1)
+            quantity = re.search(r"with quantity (\d+)", generated_text).group(1)
+            action = MoveAction(
+                slot_from=slot_from,
+                slot_to=slot_to,
+                quantity=quantity,
+            )
+            return action
+        except AttributeError as e:
+            return f"Format Error: {e}"
+
+
+class SmeltActionHandler(ActionHandlerBase):
+    @property
+    def prompt_description(self) -> str:
+        return "Smelt an item in a furnace and moves the output to a specific slot"
+
+    @property
+    def prompt_format_example(self) -> str:
+        return "`smelt: from [Source] to [Target] with quantity N`"
+
+    @property
+    def action_name(self) -> str:
+        return "smelt"
+
+    def match(self, generated_text: str) -> Optional[SmeltAction | str]:
+        """
+        Parse the raw model response to a SmeltAction
+        """
+        action_match = re.search(f"({self.action_name}):", generated_text)
+        if not action_match:
+            return
+        try:
+            slot_from = re.search(r" from (\[[ABCI]?\d+\])", generated_text).group(1)
+            slot_to = re.search(r" to (\[[ABCI]?\d+\])", generated_text).group(1)
+            quantity = re.search(r"with quantity (\d+)", generated_text).group(1)
+            action = SmeltAction(
+                slot_from=slot_from,
+                slot_to=slot_to,
+                quantity=quantity,
+            )
+            return action
+        except AttributeError as e:
+            return f"Format Error: {e}"
+
+
+class ImpossibleActionHandler(ActionHandlerBase):
+    @property
+    def prompt_description(self) -> str:
+        return "Stop task if it is certain that it is impossible with given inventory"
+
+    @property
+    def prompt_format_example(self) -> str:
+        return "`impossible: <reason>`"
+
+    @property
+    def action_name(self) -> str:
+        return "impossible"
+
+    def match(self, generated_text) -> Optional[StopAction]:
+        """
+        Parse the raw model response to a StopAction
+        """
+        action_match = re.search(f"({self.action_name}):", generated_text)
+        if not action_match:
+            return
+        reason = re.search(r"impossible: (.*)", generated_text).group(1)
+        return StopAction(reason=reason)
+
+
+class ThinkActionHandler(ActionHandlerBase):
+    @property
+    def prompt_description(self) -> str:
+        return "Generate thoughts to help you decide on the next action"
+
+    @property
+    def prompt_format_example(self) -> str:
+        return "`think: <thought message>`"
+
+    @property
+    def action_name(self) -> str:
+        return "think"
+
+    def match(self, generated_text) -> Optional[str]:
+        """
+        Parse the raw model response to a ThinkAction
+        """
+        action_match = re.search(f"({self.action_name}):", generated_text)
+        if not action_match:
+            return
+        return "Ok"

plancraft/{environments → environment}/env.py

@@ -1,23 +1,51 @@
 import glob
 import os
-from collections import defaultdict
 from typing import Literal, Optional
 
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 
-from plancraft.environments.actions import SymbolicAction
-from plancraft.environments.recipes import (
+from plancraft.environment.actions import SymbolicAction, convert_from_slot_index
+from plancraft.environment.recipes import (
     RECIPES,
     ShapedRecipe,
     ShapelessRecipe,
     SmeltingRecipe,
     convert_ingredients_to_table,
 )
-from plancraft.environments.sampler import MAX_STACK_SIZE
+from plancraft.environment.sampler import MAX_STACK_SIZE
 
 
-class CraftingTableUI:
+def get_objective_str(target: str) -> str:
+    return f"Craft an item of type: {target}"
+
+
+def target_and_inventory_to_text_obs(target: str, inventory: dict) -> str:
+    """
+    Convert inventory dict to text observation
+    """
+    objective = get_objective_str(target)
+    inventory_str = ""
+    # sort by slot number
+    for slot, item in sorted(inventory.items(), key=lambda item: item[0]):
+        # skip items with quantity 0
+        if item["quantity"] <= 0:
+            continue
+        slot_str = convert_from_slot_index(slot)
+        inventory_str += f"\n - {item['type']} {slot_str} quantity {item['quantity']}"
+    return f"{objective}\ninventory:{inventory_str}"
+
+
+def text_obs_to_objective_and_inventory(
+    text_observation: str,
+) -> tuple[str, list[dict]]:
+    """
+    Parser for text observation back to target object and inventory dict
+    """
+    raise NotImplementedError()
+
+
+class CraftingTableGUI:
     """
     Class to render a crafting table with items and quantities.
     """
@@ -194,18 +222,18 @@ class CraftingTableUI:
         return self.current_table.size
 
 
-class PlancraftEnv:
+class PlancraftEnvironment:
     """
     Environment class for the Plancraft environment.
     """
 
-    def __init__(self, inventory: list[dict] = [], recipes=RECIPES, resolution="high"):
-        self.inventory = inventory
-
-        self.table = CraftingTableUI(resolution=resolution)
-        self.state = defaultdict(lambda: {"type": "air", "quantity": 0})
+    def __init__(
+        self, inventory: Optional[dict] = None, recipes=RECIPES, resolution="high"
+    ):
+        self.table = CraftingTableGUI(resolution=resolution)
+        self.state = {}
 
-        self.reset_state()
+        self.reset(inventory)
 
         self.table_indexes = list(range(1, 10))
         self.output_index = 0
@@ -231,82 +259,77 @@ class PlancraftEnv:
 
     def remove_item_from_slot(self, slot: int):
         self.table.remove_item_from_slot(slot)
-        self.state[slot] = {"type": "air", "quantity": 0}
+        if slot in self.state:
+            del self.state[slot]  # Remove the slot from the dictionary
 
     def change_quantity_in_slot(self, slot: int, quantity: int = 1):
         if quantity == 0:
             self.remove_item_from_slot(slot)
             return
 
-        assert quantity > 0 and quantity <= 64
+        assert 0 < quantity <= 64
+        assert slot in self.state, "Slot does not exist in the inventory"
+
         self.state[slot]["quantity"] = quantity
         # update visual representation by removing and adding the item with the new quantity
         self.table.remove_item_from_slot(slot)
         self.table.add_item_to_slot(self.state[slot]["type"], slot, quantity)
 
-    def reset_state(self):
+    def reset(self, new_inventory: Optional[dict] = None):
         self.table.clear()
-        for slot in range(46):
-            self.remove_item_from_slot(slot)
-        # initialise inventory
-        for item in self.inventory:
-            self.add_item_to_slot(item["type"], item["slot"], item["quantity"])
+        self.state = {}  # Start with an empty dictionary
+        # Initialise inventory
+        if new_inventory:
+            for slot, item in new_inventory.items():
+                assert "type" in item and "quantity" in item
+                assert slot >= 0 and slot < 46
+                assert item["quantity"] > 0 and item["quantity"] <= 64
+                self.state[slot] = item
+        return self.state
 
-    def step(self, action: Optional[SymbolicAction | dict] = None):
+    def step(self, action: Optional[SymbolicAction] = None) -> dict:
         # default no op action
         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, "pov": self.table.frame}
-
-        # action_dict = action.to_action_dict()
-        if not isinstance(action, dict):
-            action = action.to_action_dict()
+            return {"inventory": dict(self.state), "image": self.table.frame}
 
-        if "inventory_command" in action:
+        if action.action_type == "move":
             # do inventory command (move)
-            slot, slot_to, quantity = action["inventory_command"]
-            self.move_item(slot, slot_to, quantity)
-        elif "smelt" in action:
+            self.move_item(action.slot_from, action.slot_to, action.quantity)
+        elif action.action_type == "smelt":
             # do smelt
-            slot, slot_to, quantity = action["smelt"]
-            self.smelt_item(slot, slot_to, quantity)
+            self.smelt_item(action.slot_from, action.slot_to, action.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, "pov": self.table.frame}
+        return {"inventory": dict(self.state), "image": self.table.frame}
 
     def clean_state(self):
         # reset slot type if quantity is 0
-        for i in self.state.keys():
-            if self.state[i]["quantity"] == 0:
-                self.remove_item_from_slot(i)
+        to_remove = [slot for slot, item in self.state.items() if item["quantity"] <= 0]
+        for slot in to_remove:
+            self.remove_item_from_slot(slot)
+
+    def slot_empty(self, slot: int) -> bool:
+        return slot not in self.state or self.state[slot]["quantity"] <= 0
 
     def move_item(self, slot_from: int, slot_to: int, quantity: int):
-        if slot_from == slot_to or quantity < 1 or slot_to == 0:
+        if slot_from == slot_to or quantity < 1:
             return
         # slot outside of inventory
-        if slot_from not in self.state or slot_to not in self.state:
+        if slot_from < 0 or slot_to < 1 or slot_from >= 46 or slot_to >= 46:
             return
         # not enough
-        if self.state[slot_from]["quantity"] < quantity:
+        if self.slot_empty(slot_from) or self.state[slot_from]["quantity"] < quantity:
+            return
+        # if craft slot - must take all
+        if slot_from == 0 and 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
-        ):
+        if self.slot_empty(slot_to):
             # add quantity to new slot
             self.add_item_to_slot(item["type"], slot_to, quantity)
             # remove quantity from old slot
@@ -327,7 +350,7 @@ class PlancraftEnv:
             return
 
         # reset slot if quantity is 0
-        if self.state[slot_from]["quantity"] == 0:
+        if self.slot_empty(slot_from):
             self.remove_item_from_slot(slot_from)
 
         # use up ingredients
@@ -339,21 +362,22 @@ class PlancraftEnv:
             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:
+        if quantity < 1 or slot_from == slot_to:
             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
+        # handle slot out of bounds or invalid slot numbers
+        if slot_from < 1 or slot_to < 1 or slot_from >= 46 or slot_to >= 46:
+            return
 
         item = self.state[slot_from]
-        if item["quantity"] < quantity or item["type"] == "air":
+        if self.slot_empty(slot_from) or item["quantity"] < quantity:
             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":
+                if self.slot_empty(slot_to):
                     self.add_item_to_slot(output_type, slot_to, quantity)
                     self.change_quantity_in_slot(
                         slot_from, self.state[slot_from]["quantity"] - quantity
@@ -374,7 +398,7 @@ class PlancraftEnv:
                     return  # No space or type mismatch in slot_to
 
         # Clean up if the source slot is depleted
-        if self.state[slot_from] == 0:
+        if self.slot_empty(slot_from):
             self.remove_item_from_slot(slot_from)
 
         if slot_to < 10 or slot_from < 10:
@@ -384,10 +408,10 @@ class PlancraftEnv:
         # 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:
+            if self.slot_empty(i):
                 ingredients.append(None)
+            else:
+                ingredients.append(self.state[i]["type"])
         table = convert_ingredients_to_table(ingredients)
 
         # check if any of the crafting recipes match the ingredients
@@ -410,8 +434,3 @@ class PlancraftEnv:
                 self.remove_item_from_slot(idx + 1)
 
         self.ingredients_idxs = []
-
-    def reset(self, new_inventory: list[dict]):
-        self.inventory = new_inventory
-        self.reset_state()
-        return self.state

plancraft/{environments → environment}/planner.py

@@ -2,7 +2,7 @@ import time
 
 import networkx as nx
 
-from plancraft.environments.recipes import RECIPES, BaseRecipe
+from plancraft.environment.recipes import RECIPES, BaseRecipe
 
 RECIPE_GRAPH = nx.DiGraph()