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

{plancraft-0.1.4.dist-info → plancraft-0.2.0.dist-info}/WHEEL

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

plancraft/environments/env_real.py

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

@@ -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()

plancraft-0.1.4.dist-info/METADATA

@@ -1,74 +0,0 @@
-Metadata-Version: 2.1
-Name: plancraft
-Version: 0.1.4
-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).