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

plancraft/config.py

@@ -0,0 +1,155 @@
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, model_validator
+
+try:
+    from plancraft.environments.recipes import RECIPES
+except ImportError:
+    RECIPES = {}
+
+DatasetSplit = Literal[
+    "train", "val", "val.small", "val.small.easy", "test", "test.small"
+]
+
+
+class EnvironmentConfig(BaseModel):
+    symbolic: bool
+    symbolic_observation_space: bool
+    symbolic_action_space: bool
+    preferred_spawn_biome: str = "plains"
+    resolution: list[int] = [512, 512]
+
+
+class PlancraftConfig(BaseModel):
+    model: str
+    adapter: str = ""
+    tokenizer: str
+    num_generations: int
+    mode: Literal["react", "act", "oracle", "dummy"] = "react"
+    output_dir: str
+    max_steps: int = 30  # max number of steps (smelt/move) to take in the environment before stopping
+    quantize: Literal[False, "int4", "int8"]
+    environment: EnvironmentConfig
+    split: DatasetSplit = "val.small"
+    max_message_window: int = 30  # max number of messages to keep in dialogue history (30 is around 8k llama3 tokens)
+    hot_cache: bool = True  # whether to cache the dialogue history between steps
+    resume: bool = True  # resume inference
+    few_shot: bool = True  # whether to use few-shot prompt
+    system_prompt: bool = True  # whether to use system prompt
+    valid_actions: list[str] = ["move", "smelt", "think", "search", "impossible"]
+    use_maskrcnn: bool = False  # whether to use maskrcnn for multimodal parsing
+
+    # observations
+    use_text_inventory: bool = True  # whether to include inventory in text
+    use_images: bool = False  # whether to include images in multimodal content
+    use_multimodal_content_format: bool = (
+        False  # whether to use multimodal content format
+    )
+
+    @model_validator(mode="after")
+    def validate(self):
+        assert set(
+            self.valid_actions
+        ).issubset(
+            {"move", "smelt", "think", "search", "impossible"}
+        ), "valid_actions should be subset of {'move', 'smelt', 'think', 'search', 'impossible'}"
+
+        if self.use_images:
+            assert (
+                not self.environment.symbolic
+            ), "Set environment.symbolic to False when using images"
+
+        return self
+
+
+class WandbConfig(BaseModel):
+    project: str
+    entity: str
+    mode: str
+
+
+class LaunchConfig(BaseModel):
+    command: str
+    job_name: str
+    gpu_limit: int
+    gpu_product: str
+    cpu_request: int
+    ram_request: str
+    interactive: bool = False
+    namespace: str = "informatics"
+    env_vars: dict[str, dict[str, str]]
+
+
+class EvalConfig(BaseModel):
+    plancraft: PlancraftConfig
+    wandb: WandbConfig
+    launch: LaunchConfig
+
+
+class TrainingArgs(BaseModel):
+    base_model: str = "llama3"
+    trace_mode: str = "oa"
+    push_to_hub: bool = False
+
+    # uses less space but not working with multi-gpu training..
+    qlora: bool = False
+
+    lora_alpha: int = 16
+    lora_dropout: float = 0.1
+    lora_r: int = 64
+    # training data args
+    seed: int = 42
+    # model args
+    batch_size: int = 1
+    max_seq_length: int = 8142
+    max_message_window: int = 100
+    only_assistant: bool = True
+
+    # training args
+    gradient_accumulation_steps: int = 4
+    learning_rate: float = 2e-4
+    max_grad_norm: float = 0.3
+    warmup_ratio: float = 0.03
+    num_train_epochs: int = 3
+    num_workers: int = 1
+
+
+class TrainConfig(BaseModel):
+    training: TrainingArgs
+    wandb: WandbConfig
+    launch: LaunchConfig
+
+
+class PlancraftExample(BaseModel):
+    target: str
+    inventory: dict[str, int]
+    slotted_inventory: list[dict[str, Union[str, int]]]
+    num_distractors: int
+    impossible: bool
+    optimal_path_length: Optional[int]
+    optimal_path: Optional[list[str]]
+    inventory_trace: Optional[list[dict[str, int]]]
+    items_used: Optional[int]
+    unique_items_used: Optional[int]
+    complexity: Optional[int]
+    complexity_bin: int
+    unseen_in_train: bool
+    unseen_in_val: bool
+    split: DatasetSplit
+    id: str
+
+    recipe_type: Optional[str] = ""
+
+    # post processing set recipe type
+    def model_post_init(self, __context):
+        recipe_types = set()
+        if self.optimal_path is None:
+            self.recipe_type = "impossible"
+            return
+        for step in self.optimal_path:
+            for r in RECIPES[step]:
+                recipe_types.add(r.recipe_type)
+        if len(recipe_types) == 1:
+            self.recipe_type = recipe_types.pop()
+        else:
+            self.recipe_type = "mixed"

plancraft/evaluator.py

@@ -0,0 +1,273 @@
+import json
+import os
+import random
+import string
+import time
+
+import imageio
+import pandas as pd
+import torch
+import wandb
+from loguru import logger
+from tqdm import tqdm
+
+from plancraft.config import EvalConfig, PlancraftExample
+from plancraft.environments.actions import StopAction
+from plancraft.environments.env_real import RealPlancraft
+from plancraft.environments.env_symbolic import SymbolicPlancraft
+from plancraft.models import get_model
+
+wandb.require("core")
+
+
+class Evaluator:
+    """
+    The evaluator class handles the environment loop and model interaction
+
+    The environment is created based on the configuration and the examples are loaded from the dataset.
+    """
+
+    def __init__(self, cfg: EvalConfig):
+        self.cfg = cfg
+        self.output_dir = (
+            f"{cfg.plancraft.output_dir}/{self.evaluator_name()}/{cfg.plancraft.split}"
+        )
+        self.generation_number = 0
+
+        self.examples: list[PlancraftExample] = self.load_dataset(cfg.plancraft.split)
+
+        self.environment = self.create_env(cfg)
+        self.model = get_model(cfg)
+
+        self.record_frames = not (cfg.plancraft.environment.symbolic)
+
+        # no_op action
+        self.no_op = self.environment.action_space.no_op()
+
+    def evaluator_name(self) -> str:
+        symb_str = "real"
+        if self.cfg.plancraft.environment.symbolic:
+            symb_str = "symb"
+
+        if self.cfg.plancraft.use_maskrcnn:
+            symb_str += "_mrcnn"
+
+        model_name = self.cfg.plancraft.model.split("/")[-1]
+        if self.cfg.plancraft.adapter != "":
+            model_name = self.cfg.plancraft.adapter.split("/")[-1]
+
+        mode = self.cfg.plancraft.mode
+        if mode in ["dummy", "oracle"]:
+            return f"{mode}_{symb_str}"
+
+        actions = "|".join(self.cfg.plancraft.valid_actions)
+        return f"{self.cfg.plancraft.mode}_{symb_str}_{model_name}_{actions}"
+
+    def save_results_dict(self, example: PlancraftExample, results_dict: dict):
+        output_dir = f"{self.output_dir}/{self.generation_number}"
+        os.makedirs(output_dir, exist_ok=True)
+        json_path = f"{output_dir}/{example.id}.json"
+        with open(json_path, "w") as f:
+            json.dump(results_dict, f, indent=4)
+        wandb.save(json_path, policy="now")
+
+    def save_images(self, example: PlancraftExample, frames: list):
+        if len(frames) == 0:
+            return
+        output_dir = f"{self.output_dir}/{self.generation_number}"
+        os.makedirs(output_dir, exist_ok=True)
+        imageio.mimsave(f"{output_dir}/{example.id}.gif", frames)
+        # upload to wandb
+        wandb.save(f"{output_dir}/{example.id}.gif", policy="now")
+
+    def load_results_dict(self, example: PlancraftExample) -> dict:
+        path = f"{self.output_dir}/{self.generation_number}/{example.id}.json"
+        if not os.path.exists(path) or not self.cfg.plancraft.resume:
+            return None
+        with open(path, "r") as f:
+            return json.load(f)
+
+    def create_env(self, cfg: EvalConfig) -> RealPlancraft | SymbolicPlancraft:
+        if cfg.plancraft.environment.symbolic:
+            return SymbolicPlancraft(inventory=[])
+        return RealPlancraft(
+            inventory=[],
+            symbolic_action_space=cfg.plancraft.environment.symbolic_action_space,
+            symbolic_observation_space=cfg.plancraft.environment.symbolic_observation_space,
+            preferred_spawn_biome=cfg.plancraft.environment.preferred_spawn_biome,
+            resolution=cfg.plancraft.environment.resolution,
+        )
+
+    def close(self):
+        self.environment.close()
+
+    def load_dataset(self, dataset_split: str) -> list[PlancraftExample]:
+        with open(f"data/{dataset_split}.json", "r") as f:
+            dataset = json.load(f)
+            return [PlancraftExample(**example) for example in dataset]
+
+    def reset(
+        self,
+        example: PlancraftExample,
+    ):
+        current_inventory = example.slotted_inventory
+        self.environment.fast_reset(new_inventory=current_inventory)
+        # do a no op to an initial observation
+        obs, _, _, _ = self.environment.step(self.no_op)
+        # assert that the inventory is correct
+        if "inventory" in obs:
+            for item in current_inventory:
+                slot = item["slot"]
+                if (
+                    obs["inventory"][slot]["type"] != item["type"]
+                    or obs["inventory"][slot]["quantity"] != item["quantity"]
+                ) and item["type"] != "air":
+                    logger.warning(f"Inventory does not match expected for slot {slot}")
+                    logger.warning(f"Expected {item}")
+                    logger.warning(f"Got {obs['inventory'][slot]}")
+                    # try again
+                    self.reset(example)
+
+        objective = f"Craft an item of type: {example.target}"
+        self.model.reset_history(objective=objective)
+
+    def check_done(self, inventory: list[dict[str, int]], target: str):
+        """
+        Check that target object is obtained
+        """
+        for item in inventory:
+            if target == item["type"]:
+                # ensure item is taken out of crafting slot
+                if "slot" in item and item["slot"] != 0:
+                    return True
+                if "index" in item and item["index"] != 0:
+                    return True
+        return False
+
+    @torch.no_grad()
+    def eval_all_examples(self, progress_bar=False) -> list:
+        results = []
+        action = self.no_op.copy()
+
+        pbar = tqdm(
+            total=len(self.examples),
+            disable=not progress_bar,
+        )
+        correct = 0
+        count = 0
+
+        for example in self.examples:
+            if resume_result := self.load_results_dict(example):
+                pbar.update(self.cfg.plancraft.max_steps)
+                results.append(resume_result)
+                continue
+
+            success = False
+
+            self.reset(example)
+            action = self.no_op.copy()
+
+            while (
+                not self.model.history.check_stuck()
+                and self.model.history.num_steps < self.cfg.plancraft.max_steps
+            ):
+                # if the action is stop then we end the episode
+                if isinstance(action, StopAction):
+                    # if the action is stop and task is impossible then success
+                    # otherwise we should not have stopped
+                    success = example.impossible
+                    break
+
+                # step action
+                observation, _, _, _ = self.environment.step(action)
+
+                # check if the episode is done
+                success = self.check_done(observation["inventory"], example.target)
+                # exit if success
+                if success:
+                    break
+
+                # predict next action
+                action = self.model.step(observation)
+
+            # save results and reset
+            result = {
+                "success": success,
+                "recipe_type": example.recipe_type,
+                "number_of_steps": self.model.history.num_steps,
+                "model_trace": self.model.history.trace(),
+                "example_id": example.id,
+                "impossible": example.impossible,
+            }
+            results.append(result)
+            self.save_results_dict(example, result)
+            self.save_images(example, self.model.history.images)
+
+            correct += int(result["success"])
+            count += 1
+
+            acc = correct / count
+            pbar.set_postfix(correct=correct, count=count, acc=acc)
+            pbar.update(1)
+
+        return results
+
+    def eval_all(self):
+        logger.info(
+            f"Running evaluation over {len(self.examples)} examples {self.cfg.plancraft.num_generations} times."
+        )
+        run_name = (
+            f"{self.evaluator_name()} {self.cfg.plancraft.split}".replace(" ", "_")
+            .replace(".", "_")
+            .strip()
+        )
+
+        for n in range(self.cfg.plancraft.num_generations):
+            logger.info(f"Generation {n+1}/{self.cfg.plancraft.num_generations}")
+            run_id = "".join(random.choices(string.ascii_lowercase, k=5))
+            generation_run_name = run_name + f"_{run_id}"
+
+            wandb.init(
+                name=generation_run_name,
+                project=self.cfg.wandb.project,
+                entity=self.cfg.wandb.entity,
+                mode=self.cfg.wandb.mode,
+                group=self.cfg.plancraft.model,
+                job_type=self.cfg.plancraft.mode,
+                config=self.cfg.model_dump(),
+            )
+            time_now = time.time()
+
+            results_list = self.eval_all_examples(progress_bar=True)
+
+            results_df = pd.DataFrame(results_list)
+
+            output = {
+                "avg_success_rate": results_df["success"].mean(),
+                "avg_number_of_steps": results_df["number_of_steps"].mean(),
+                "avg_num_tokens_used": results_df["model_trace"]
+                .apply(pd.Series)["tokens_used"]
+                .mean(),
+            }
+
+            # calculate success rate for each recipe type
+            recipe_types = results_df["recipe_type"].unique()
+            for recipe_type in recipe_types:
+                mask = results_df["recipe_type"] == recipe_type
+                success_rate = results_df[mask]["success"].mean()
+                output[f"{recipe_type}_success_rate"] = success_rate
+
+            time_elapsed = time.time() - time_now
+            logger.info(f"Time elapsed: {time_elapsed:.2f}s")
+
+            logger.info(output)
+            wandb.log(output)
+            table = wandb.Table(
+                dataframe=results_df[["success", "number_of_steps", "example_id"]]
+            )
+            wandb.log({"results": table})
+            wandb.finish()
+
+            self.generation_number += 1
+
+        logger.info("Done")

plancraft/utils.py

@@ -0,0 +1,84 @@
+import glob
+import pathlib
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image
+
+
+def get_downloaded_models() -> dict:
+    """
+    Get the list of downloaded models on the NFS partition (EIDF).
+    """
+    downloaded_models = {}
+    # known models on NFS partition
+    if pathlib.Path("/nfs").exists():
+        local_models = glob.glob("/nfs/public/hf/models/*/*")
+        downloaded_models = {
+            model.replace("/nfs/public/hf/models/", ""): model for model in local_models
+        }
+    return downloaded_models
+
+
+def get_torch_device() -> torch.device:
+    device = torch.device("cpu")
+    if torch.cuda.is_available():
+        device = torch.device("cuda", 0)
+    elif torch.backends.mps.is_available():
+        if not torch.backends.mps.is_built():
+            print(
+                "MPS not available because the current PyTorch install was not built with MPS enabled."
+            )
+        else:
+            device = torch.device("mps")
+    return device
+
+
+def resize_image(img, target_resolution=(128, 128)):
+    if type(img) == np.ndarray:
+        img = cv2.resize(img, target_resolution, interpolation=cv2.INTER_LINEAR)
+    elif type(img) == torch.Tensor:
+        img = F.interpolate(img, size=target_resolution, mode="bilinear")
+    else:
+        raise ValueError("Unsupported type for img")
+    return img
+
+
+def save_frames_to_video(frames: list, out_path: str):
+    imgs = []
+    for id, (frame, goal) in enumerate(frames):
+        # if torch.is_tensor(frame):
+        # frame = frame.permute(0, 2, 3, 1).cpu().numpy()
+
+        frame = resize_image(frame, (320, 240)).astype("uint8")
+        cv2.putText(
+            frame,
+            f"FID: {id}",
+            (10, 25),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (255, 255, 255),
+            2,
+        )
+        cv2.putText(
+            frame,
+            f"Goal: {goal}",
+            (10, 55),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (255, 0, 0),
+            2,
+        )
+        imgs.append(Image.fromarray(frame))
+    imgs = imgs[::3]
+    imgs[0].save(
+        out_path,
+        save_all=True,
+        append_images=imgs[1:],
+        optimize=False,
+        quality=0,
+        duration=150,
+        loop=0,
+    )

plancraft-0.1.3.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: plancraft
+Version: 0.1.3
+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.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+plancraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plancraft/config.py,sha256=k7Ac6Zh6g-Q-fuazPxVdXnSL_PMd3jsIqyiImNaJW5A,4472
+plancraft/evaluator.py,sha256=zomShgwyUOHNVZbTERpimgEYiyD4JXzHzPi4tg45lsM,9926
+plancraft/utils.py,sha256=J9K81zBXWCcyIBjwu_eHznnzWamXU-pQrz7BdNTVbLU,2289
+plancraft/environments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+plancraft/environments/actions.py,sha256=SeeC9l1cJBs9pdba6BefQ_iQNfFf6FVTWm7HWkacbsY,6262
+plancraft/environments/env_real.py,sha256=oETMvdq8-TspPoIRxioTDj9EEmuZRuuMxd9c3momvPk,10877
+plancraft/environments/env_symbolic.py,sha256=ot4IStZ3oT7CYPqdqHsGl2BopLyZUwSF671SrHIiMLk,7777
+plancraft/environments/items.py,sha256=1R56LyK6tqIssQJMqHst6A9DeEfOX5DN-OBAkumGncw,217
+plancraft/environments/planner.py,sha256=2B-0aunllmTuiHE7Jn5jHzCg6mMgxZjisiTDdpSKupk,3954
+plancraft/environments/recipes.py,sha256=nXvOLCRljiZ5IgeevXuosU9IgSs7oQWQJFiuyRNSVFs,19571
+plancraft/environments/sampler.py,sha256=ZBYoENKdQQ7wbAyVk-c9UNRWKPE0omv9he8c8QZ6wXg,7625
+plancraft/models/__init__.py,sha256=PasK3jpbhpD0kxF4iHukcccZqvZg6lL240zie3DfLDY,622
+plancraft/models/act.py,sha256=jdZunT7FcbHvcaJZ_wUDLSuObHjU6JZybghR_B0QJ8Q,6548
+plancraft/models/base.py,sha256=fFM2BV9PqvIFtUlTz8iz5HPemYRy3S0EituM1XdJJSQ,4927
+plancraft/models/bbox_model.py,sha256=CoX-odH59S-djkPOH2ViEmbYWo1sefmHiOcBlFWiAkg,16814
+plancraft/models/dummy.py,sha256=QjxTIiKsWSmhUMAuw7Yy-OKKCLi_x3rwll4hH7ZNXso,1732
+plancraft/models/generators.py,sha256=c2avYUoXAAWOHRFq24ZYqHqNgoPs_L_XWJrR_TKFg9E,17358
+plancraft/models/oam.py,sha256=_TpxsaCnGvQ7YJC6KWcpl2HzgBiQaHn7U1zRAXfdjOo,9943
+plancraft/models/oracle.py,sha256=xRplR2cCW_39UGYtSjDLRDmp0UILhtIXYjuRJ-jokJ8,9598
+plancraft/models/prompts.py,sha256=XwoRqd_5_VfCUXb10dCRFYXgw70mO2VoQocn3Z2zgs0,6165
+plancraft/models/react.py,sha256=5yM4tv7tDfm_-5yUSAcw5C4wioWijF9fLEODbFqFDvg,3346
+plancraft/models/utils.py,sha256=osKX0_uux9wzqYzq1ST0Cu5idrAnyfNvXrj0uO1eKo0,9424
+plancraft/models/few_shot_images/__init__.py,sha256=nIkyB6w3ok-h4lfJKsrcMQzQF624Y9uxYV1FqCu3Lx0,351
+plancraft/train/dataset.py,sha256=NrZjbIkosui1kaq7AIWSrYvvzrDxu_njH7FmGKY3xnI,5434
+plancraft-0.1.3.dist-info/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
+plancraft-0.1.3.dist-info/METADATA,sha256=XLudjSvyfZ-uYJZ1K1RAJUVOQhozFD3FLzwUQeikhK4,2631
+plancraft-0.1.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+plancraft-0.1.3.dist-info/top_level.txt,sha256=yGGA9HtPKH2-pIJFrbyYhj2JF9Xj-4m0fxMPKT9FNzg,10
+plancraft-0.1.3.dist-info/RECORD,,

{plancraft-0.1.1.dist-info → plancraft-0.1.3.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.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+plancraft

plancraft-0.1.1.dist-info/METADATA

@@ -1,74 +0,0 @@
-Metadata-Version: 2.1
-Name: plancraft
-Version: 0.1.1
-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.1.dist-info/RECORD

@@ -1,26 +0,0 @@
-environments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-environments/actions.py,sha256=SeeC9l1cJBs9pdba6BefQ_iQNfFf6FVTWm7HWkacbsY,6262
-environments/env_real.py,sha256=oETMvdq8-TspPoIRxioTDj9EEmuZRuuMxd9c3momvPk,10877
-environments/env_symbolic.py,sha256=ot4IStZ3oT7CYPqdqHsGl2BopLyZUwSF671SrHIiMLk,7777
-environments/items.py,sha256=1R56LyK6tqIssQJMqHst6A9DeEfOX5DN-OBAkumGncw,217
-environments/planner.py,sha256=2B-0aunllmTuiHE7Jn5jHzCg6mMgxZjisiTDdpSKupk,3954
-environments/recipes.py,sha256=nXvOLCRljiZ5IgeevXuosU9IgSs7oQWQJFiuyRNSVFs,19571
-environments/sampler.py,sha256=ZBYoENKdQQ7wbAyVk-c9UNRWKPE0omv9he8c8QZ6wXg,7625
-models/__init__.py,sha256=PasK3jpbhpD0kxF4iHukcccZqvZg6lL240zie3DfLDY,622
-models/act.py,sha256=jdZunT7FcbHvcaJZ_wUDLSuObHjU6JZybghR_B0QJ8Q,6548
-models/base.py,sha256=fFM2BV9PqvIFtUlTz8iz5HPemYRy3S0EituM1XdJJSQ,4927
-models/bbox_model.py,sha256=CoX-odH59S-djkPOH2ViEmbYWo1sefmHiOcBlFWiAkg,16814
-models/dummy.py,sha256=QjxTIiKsWSmhUMAuw7Yy-OKKCLi_x3rwll4hH7ZNXso,1732
-models/generators.py,sha256=c2avYUoXAAWOHRFq24ZYqHqNgoPs_L_XWJrR_TKFg9E,17358
-models/oam.py,sha256=_TpxsaCnGvQ7YJC6KWcpl2HzgBiQaHn7U1zRAXfdjOo,9943
-models/oracle.py,sha256=xRplR2cCW_39UGYtSjDLRDmp0UILhtIXYjuRJ-jokJ8,9598
-models/prompts.py,sha256=XwoRqd_5_VfCUXb10dCRFYXgw70mO2VoQocn3Z2zgs0,6165
-models/react.py,sha256=5yM4tv7tDfm_-5yUSAcw5C4wioWijF9fLEODbFqFDvg,3346
-models/utils.py,sha256=osKX0_uux9wzqYzq1ST0Cu5idrAnyfNvXrj0uO1eKo0,9424
-models/few_shot_images/__init__.py,sha256=nIkyB6w3ok-h4lfJKsrcMQzQF624Y9uxYV1FqCu3Lx0,351
-train/dataset.py,sha256=NrZjbIkosui1kaq7AIWSrYvvzrDxu_njH7FmGKY3xnI,5434
-plancraft-0.1.1.dist-info/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
-plancraft-0.1.1.dist-info/METADATA,sha256=Cj-_TAlOz4PGzed9FVVTrpI0Oc0wk2s94gOSd0XaNTE,2675
-plancraft-0.1.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-plancraft-0.1.1.dist-info/top_level.txt,sha256=ZT60unZw3qNbZoGMCVc-V_0hI4YIYvTVGGScIgkCa88,26
-plancraft-0.1.1.dist-info/RECORD,,

plancraft-0.1.1.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-environments
-models
-train