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

plancraft-0.1.2.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: plancraft
+Version: 0.1.2
+Summary: Plancraft: an evaluation dataset for planning with LLM agents
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: accelerate>=1.0.1
+Requires-Dist: coloredlogs>=10.0
+Requires-Dist: daemoniker>=0.2.3
+Requires-Dist: datasets>=3.0.2
+Requires-Dist: dill>=0.3.1.1
+Requires-Dist: einops>=0.8.0
+Requires-Dist: flaky>=3.8.1
+Requires-Dist: hf-transfer>=0.1.8
+Requires-Dist: huggingface-hub>=0.26.1
+Requires-Dist: hydra-core>=1.3.2
+Requires-Dist: imagehash>=4.0.0
+Requires-Dist: imageio>=2.36.0
+Requires-Dist: inflection>=0.3.1
+Requires-Dist: ipython>=7.5.0
+Requires-Dist: jinja2>=2.11.2
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: lxml>=4.3.3
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: networkx>=3.2.1
+Requires-Dist: numpy<1.24,>=1.16.2
+Requires-Dist: openai>=1.52.2
+Requires-Dist: opencv-python>=4.1.0.25
+Requires-Dist: pandas>=2.1.0
+Requires-Dist: peft>=0.13.2
+Requires-Dist: pillow>=8.0.0
+Requires-Dist: psutil>=5.6.2
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: pyglet>=2.0.18
+Requires-Dist: pyro4>=4.76
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: requests>=2.20.0
+Requires-Dist: seaborn>=0.13.2
+Requires-Dist: setuptools>=49.2.0
+Requires-Dist: tinydb>=4.8.2
+Requires-Dist: torch>=2.5.0
+Requires-Dist: torchvision>=0.20.0
+Requires-Dist: tqdm>=4.32.2
+Requires-Dist: transformers>=4.43.3
+Requires-Dist: typing>=3.6.6
+Requires-Dist: wandb>=0.18.5
+Requires-Dist: xmltodict==0.12.0
+Provides-Extra: full
+Requires-Dist: gym<=0.23.1,>=0.19.0; extra == "full"
+
+# plancraft
+
+[![Test](https://github.com/gautierdag/plancraft/actions/workflows/test.yaml/badge.svg)](https://github.com/gautierdag/plancraft/actions/workflows/test.yaml)
+![Python Version](https://img.shields.io/badge/python-3.9+-blue)
+![Ruff](https://img.shields.io/badge/linter-ruff-blue)
+[![PyPI Version](https://img.shields.io/pypi/v/plancraft)](https://pypi.org/project/plancraft/)
+
+Plancraft is a minecraft environment and agent that innovates on planning LLM agents with a retriever
+
+You can install the package by running the following command:
+
+```bash
+pip install plancraft
+```
+
+Should you need the multimodal version of the package, you will also need a custom [fork](https://github.com/gautierdag/minerl.git) of the minerl package. You can install it by running the following command:
+
+```bash
+pip install git+hhttps://github.com/gautierdag/minerl.git
+```
+
+Note that you may need to follow the same installation instructions as in the [minerl documentation](https://minerl.readthedocs.io/en/latest/tutorials/index.html).

plancraft-0.1.2.dist-info/RECORD

@@ -0,0 +1,5 @@
+plancraft-0.1.2.dist-info/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
+plancraft-0.1.2.dist-info/METADATA,sha256=IDsYHFCvjx4Nhe4Jgyj0x7YsIVAR95ZyrSA-LIQBgeI,2631
+plancraft-0.1.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+plancraft-0.1.2.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+plancraft-0.1.2.dist-info/RECORD,,

{plancraft-0.1.0.dist-info → plancraft-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

plancraft-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+

environments/actions.py

@@ -1,218 +0,0 @@
-from typing import Union
-
-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 SymbolicMoveAction(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")
-
-    def to_action_dict(self) -> dict:
-        return {
-            "inventory_command": [self.slot_from, self.slot_to, self.quantity],
-        }
-
-
-class SymbolicSmeltAction(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")
-
-    def to_action_dict(self) -> dict:
-        return {
-            "smelt": [self.slot_from, self.slot_to, self.quantity],
-        }
-
-
-class ThinkAction(BaseModel):
-    """Think about the answer before answering"""
-
-    thought: str
-
-    def to_action_dict(self) -> dict:
-        return {}
-
-
-class SearchAction(BaseModel):
-    """Searches for a relevant document in the wiki"""
-
-    search_string: str
-
-    def to_action_dict(self) -> dict:
-        return {
-            "search": self.search_string,
-        }
-
-
-class RealActionInteraction(BaseModel):
-    mouse_direction_x: float = 0
-    mouse_direction_y: float = 0
-    right_click: bool = False
-    left_click: bool = False
-
-    @field_validator("mouse_direction_x", "mouse_direction_y")
-    def prevent_zero(cls, v):
-        if v > 10:
-            return 10
-        elif v < -10:
-            return -10
-        return v
-
-    def to_action_dict(self) -> dict:
-        return {
-            "camera": [self.mouse_direction_x, self.mouse_direction_y],
-            "use": int(self.right_click),
-            "attack": int(self.left_click),
-        }
-
-
-class StopAction(BaseModel):
-    """
-    Action that model can take to stop planning - decide impossible to continue
-    Note: also known as the "impossible" action
-    """
-
-    reason: str = ""
-
-
-class NoOp(SymbolicMoveAction):
-    """No operation action - special instance of move"""
-
-    def __init__(self):
-        super().__init__(slot_from=0, slot_to=1, quantity=1)
-        self.slot_to = 0
-
-    def __call__(self, *args, **kwargs):
-        return None
-
-    def __str__(self):
-        return "NoOp"
-
-
-# when symbolic action is true, can either move objects around or smelt
-SymbolicAction = SymbolicMoveAction  # | SymbolicSmeltAction
-
-# when symbolic action is false, then need to use mouse to move things around, but can use smelt action
-RealAction = RealActionInteraction | SymbolicSmeltAction
-
-
-class PydanticSymbolicAction(BaseModel):
-    root: Union[SymbolicMoveAction, SymbolicSmeltAction]

environments/env_real.py

@@ -1,315 +0,0 @@
-from typing import Sequence, Union
-
-import numpy as np
-import json
-
-
-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
-except ImportError as e:
-    raise ImportError(
-        "The 'minerl' package is required to use RealPlancraft. "
-        "Please install it using 'pip install plancraft[full]' or 'pip install minerl'."
-    ) from e
-
-
-from plancraft.environments.actions import RealAction
-
-
-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})