plancraft 0.3.14__py3-none-any.whl → 0.3.16__py3-none-any.whl

plancraft/environment/planner.py

@@ -1,8 +1,23 @@
+import copy
 import time
+from collections import Counter
 
 import networkx as nx
 
-from plancraft.environment.recipes import RECIPES, BaseRecipe
+from plancraft.environment.actions import (
+    MoveAction,
+    SmeltAction,
+    StopAction,
+)
+from plancraft.environment.recipes import (
+    RECIPES,
+    BaseRecipe,
+    ShapedRecipe,
+    ShapelessRecipe,
+    SmeltingRecipe,
+    id_to_item,
+)
+from plancraft.environment.items import all_data
 
 RECIPE_GRAPH = nx.DiGraph()
 
@@ -14,6 +29,14 @@ for item, recipes in RECIPES.items():
             RECIPE_GRAPH.add_edge(ingredient, recipe.result.item)
 
 
+MAX_STACK_SIZE = {}
+for data_item in all_data["items"]:
+    if data_item["stackable"]:
+        MAX_STACK_SIZE[data_item["type"]] = data_item["stackSize"]
+    else:
+        MAX_STACK_SIZE[data_item["type"]] = 1
+
+
 def get_ancestors(target: str):
     return list(nx.ancestors(RECIPE_GRAPH, source=target))
 
@@ -107,3 +130,370 @@ def optimal_planner(
 
     except TimeoutError:
         return None
+
+
+def item_set_id_to_type(item_set_ids: set[int]):
+    return set(id_to_item(i) for i in item_set_ids)
+
+
+def find_free_inventory_slot(
+    inventory: dict, from_slot: int, from_item_type=None, from_item_quantity=None
+) -> int:
+    # find a free slot in the inventory for the item in from_slot
+    if from_item_type is None:
+        from_item_type = inventory[from_slot]["type"]
+    if from_item_quantity is None:
+        from_item_quantity = inventory[from_slot]["quantity"]
+
+    empty_slots = set(range(10, 46)) - set(inventory.keys()) - set([from_slot])
+
+    type_to_slot = {}
+    slot_to_quantity = {}
+    for slot, item in inventory.items():
+        if slot == from_slot:
+            continue
+        item_type = item["type"]
+        if item_type not in type_to_slot:
+            type_to_slot[item_type] = [slot]
+        else:
+            type_to_slot[item_type].append(slot)
+
+        slot_to_quantity[slot] = item["quantity"]
+
+    assert from_item_type is not None, f"Item not found in slot {from_slot}"
+
+    # if there is a free slot with the same item type
+    if from_item_type in type_to_slot:
+        for slot in type_to_slot[from_item_type]:
+            if (
+                slot_to_quantity[slot] + from_item_quantity
+                <= MAX_STACK_SIZE[from_item_type]
+            ):
+                return slot
+    if len(empty_slots) > 0:
+        return empty_slots.pop()
+
+    raise ValueError("No free slot found")
+
+
+def find_item_in_inventory(
+    target: str, inventory: dict, min_quantity_needed: set = set()
+) -> int:
+    for slot, item in inventory.items():
+        if item["type"] == target and item["quantity"] > 0:
+            # if we don't need to keep an item in the slot, we can use it
+            if slot not in min_quantity_needed:
+                return slot
+            # if we need to keep an item in the slot, we can only use it quantity>1
+            elif item["quantity"] > 1:
+                return slot
+
+
+def get_inventory_counter(inventory: dict) -> Counter:
+    counter = Counter()
+    for slot, item in inventory.items():
+        if slot == 0:
+            continue
+        counter[item["type"]] += item["quantity"]
+    return counter
+
+
+def get_crafting_slot_item(inventory: dict) -> dict:
+    for slot, item in inventory.items():
+        if slot == 0 and item["quantity"] > 0:
+            return item
+    return None
+
+
+def update_inventory(
+    inventory: dict, slot_from: int, slot_to: int, quantity: int
+) -> dict:
+    """
+    decrements quantity of item in slot_from
+    NOTE: we don't care about incrementing the items in slot_to
+
+    """
+    new_inventory = dict(inventory)
+    from_item = new_inventory[slot_from]
+    if slot_to not in new_inventory:
+        new_inventory[slot_to] = {"type": from_item["type"], "quantity": quantity}
+    else:
+        new_inventory[slot_to]["quantity"] += quantity
+
+    new_inventory[slot_from]["quantity"] -= quantity
+    if new_inventory[slot_from]["quantity"] <= 0:
+        del new_inventory[slot_from]
+    return new_inventory
+
+
+def get_plan(observation: dict):
+    # this simply recovering the target item to craft
+    inventory_counter = get_inventory_counter(observation["inventory"])
+    return optimal_planner(target=observation["target"], inventory=inventory_counter)
+
+
+def decompose_subgoal(
+    current_inventory: dict, plan_recipe, new_inventory: dict[str, int]
+) -> list[str]:
+    """
+    For a given plan_recipe and inventory, output the list of action to craft recipe
+    """
+    subplan = []
+    new_inventory_counter = Counter(new_inventory)
+    current_inventory_counter = get_inventory_counter(current_inventory)
+    items_to_use_counter = current_inventory_counter - new_inventory_counter
+    new_items = new_inventory_counter - current_inventory_counter
+    assert len(new_items) == 1
+
+    # if plan_recipe is a smelting recipe
+    if isinstance(plan_recipe, SmeltingRecipe):
+        assert len(items_to_use_counter) == 1, "smelting only supports one item"
+        for item, quantity in items_to_use_counter.items():
+            from_slot = find_item_in_inventory(item, current_inventory)
+            out_item_type, out_item_quantity = (
+                plan_recipe.result.item,
+                plan_recipe.result.count,
+            )
+            # find a free slot in the inventory for the item that will be smelted
+            free_slot = find_free_inventory_slot(
+                current_inventory,
+                from_slot=from_slot,
+                from_item_type=out_item_type,
+                from_item_quantity=out_item_quantity,
+            )
+            action = SmeltAction(
+                slot_from=from_slot, slot_to=free_slot, quantity=quantity
+            )
+            subplan.append(str(action))
+
+            # update inventory to decrement quantity of item in from_slot and increment quantity of item in free_slot
+            current_inventory = dict(current_inventory)
+            if free_slot not in current_inventory:
+                current_inventory[free_slot] = {
+                    "type": out_item_type,
+                    "quantity": out_item_quantity,
+                }
+            else:
+                current_inventory[free_slot]["quantity"] += quantity
+
+            current_inventory[from_slot]["quantity"] -= quantity
+            if current_inventory[from_slot]["quantity"] <= 0:
+                del current_inventory[from_slot]
+
+            return subplan, current_inventory
+
+    elif isinstance(plan_recipe, ShapelessRecipe):
+        crafting_slot = 1
+        min_quantity_needed = set()
+        while crafting_slot < 10:
+            # if something is already in the crafting slot
+            if (
+                crafting_slot in current_inventory
+                and current_inventory[crafting_slot]["quantity"] > 0
+            ):
+                # check it is a desired item
+                crafting_slot_item = current_inventory[crafting_slot]["type"]
+                # if it is a desired item, skip it
+                if (
+                    crafting_slot_item in items_to_use_counter
+                    and items_to_use_counter[crafting_slot_item] > 0
+                ):
+                    items_to_use_counter[crafting_slot_item] -= 1
+                    if items_to_use_counter[crafting_slot_item] == 0:
+                        del items_to_use_counter[crafting_slot_item]
+                    min_quantity_needed.add(crafting_slot)
+                    crafting_slot += 1
+                    continue
+                # if it is not a desired item, move it to a free slot
+                else:
+                    free_slot = find_free_inventory_slot(
+                        current_inventory, from_slot=crafting_slot
+                    )
+                    action = MoveAction(
+                        slot_from=crafting_slot,
+                        slot_to=free_slot,
+                        quantity=current_inventory[crafting_slot]["quantity"],
+                    )
+                    subplan.append(str(action))
+                    current_inventory = update_inventory(
+                        current_inventory,
+                        crafting_slot,
+                        free_slot,
+                        current_inventory[crafting_slot]["quantity"],
+                    )
+
+            # if there are still items to add
+            if len(items_to_use_counter) != 0:
+                item = next(iter(items_to_use_counter))
+                from_slot = find_item_in_inventory(
+                    item, current_inventory, min_quantity_needed
+                )
+                action = MoveAction(
+                    slot_from=from_slot, slot_to=crafting_slot, quantity=1
+                )
+                subplan.append(str(action))
+                current_inventory = update_inventory(
+                    current_inventory, from_slot, crafting_slot, 1
+                )
+                items_to_use_counter[item] -= 1
+                if items_to_use_counter[item] == 0:
+                    del items_to_use_counter[item]
+
+            # update state of inventory
+            crafting_slot += 1
+
+    # if plan_recipe is a shaped recipe
+    elif isinstance(plan_recipe, ShapedRecipe):
+        min_quantity_needed = set()
+        seen_kernel = set()
+        for i, row in enumerate(plan_recipe.kernel):
+            for j, item_set in enumerate(row):
+                inventory_position = (i * 3) + j + 1
+                seen_kernel.add(inventory_position)
+                valid_items = item_set_id_to_type(item_set)
+
+                # if the inventory position is needed to be empty
+                if (
+                    valid_items == {None}
+                    and inventory_position in current_inventory
+                    and current_inventory[inventory_position]["quantity"] > 0
+                ):
+                    free_slot = find_free_inventory_slot(
+                        current_inventory, from_slot=inventory_position
+                    )
+                    action = MoveAction(
+                        slot_from=inventory_position,
+                        slot_to=free_slot,
+                        quantity=current_inventory[inventory_position]["quantity"],
+                    )
+                    current_inventory = update_inventory(
+                        current_inventory,
+                        inventory_position,
+                        free_slot,
+                        current_inventory[inventory_position]["quantity"],
+                    )
+                    subplan.append(str(action))
+                    continue
+
+                # if the inventory position is needed to be filled
+                added_item = False
+                for item in valid_items:
+                    # check if item is already added
+                    if added_item:
+                        break
+
+                    # if item is already in the correct position, skip
+                    if (
+                        inventory_position in current_inventory
+                        and current_inventory[inventory_position]["type"] == item
+                    ) and current_inventory[inventory_position]["quantity"] > 0:
+                        min_quantity_needed.add(inventory_position)
+                        # decrement the quantity of the items to use
+                        items_to_use_counter[item] -= 1
+                        if items_to_use_counter[item] == 0:
+                            del items_to_use_counter[item]
+                        break
+
+                    if items_to_use_counter[item] > 0:
+                        # check and remove any item in the inventory position
+                        if (
+                            inventory_position in current_inventory
+                            and current_inventory[inventory_position]["quantity"] > 0
+                            and current_inventory[inventory_position]["type"] != item
+                        ):
+                            free_slot = find_free_inventory_slot(
+                                current_inventory, from_slot=inventory_position
+                            )
+                            action = MoveAction(
+                                slot_from=inventory_position,
+                                slot_to=free_slot,
+                                quantity=current_inventory[inventory_position][
+                                    "quantity"
+                                ],
+                            )
+                            current_inventory = update_inventory(
+                                current_inventory,
+                                inventory_position,
+                                free_slot,
+                                current_inventory[inventory_position]["quantity"],
+                            )
+                            subplan.append(str(action))
+
+                        # move item to correct position
+                        from_slot = find_item_in_inventory(
+                            item, current_inventory, min_quantity_needed
+                        )
+                        action = MoveAction(
+                            slot_from=from_slot,
+                            slot_to=inventory_position,
+                            quantity=1,
+                        )
+                        items_to_use_counter[item] -= 1
+                        added_item = True
+                        # update state of inventory
+                        current_inventory = update_inventory(
+                            current_inventory, from_slot, inventory_position, 1
+                        )
+                        subplan.append(str(action))
+
+        # ensure all other items are removed
+        leftover_kernel = set(range(1, 10)) - seen_kernel
+        for slot in leftover_kernel:
+            if slot in current_inventory and current_inventory[slot]["quantity"] > 0:
+                free_slot = find_free_inventory_slot(current_inventory, from_slot=slot)
+                action = MoveAction(
+                    slot_from=slot,
+                    slot_to=free_slot,
+                    quantity=current_inventory[slot]["quantity"],
+                )
+                current_inventory = update_inventory(
+                    current_inventory,
+                    slot,
+                    free_slot,
+                    current_inventory[slot]["quantity"],
+                )
+                subplan.append(str(action))
+    else:
+        raise NotImplementedError(f"Recipe type {type(plan_recipe)} not supported")
+
+    # move crafted item to free slot
+    current_inventory[0] = {
+        "type": plan_recipe.result.item,
+        "quantity": plan_recipe.result.count,
+    }
+    free_slot = find_free_inventory_slot(current_inventory, from_slot=0)
+    subplan.append(
+        str(
+            MoveAction(
+                slot_from=0, slot_to=free_slot, quantity=plan_recipe.result.count
+            )
+        )
+    )
+    current_inventory = update_inventory(
+        current_inventory, 0, free_slot, plan_recipe.result.count
+    )
+    # decrement all quantities of items present in crafting slots
+    for i in range(1, 10):
+        if i in current_inventory:
+            current_inventory[i]["quantity"] -= 1
+            if current_inventory[i]["quantity"] <= 0:
+                del current_inventory[i]
+
+    return subplan, current_inventory
+
+
+def get_subplans(observation: dict) -> tuple[list[list[str]], list]:
+    current_inventory = copy.deepcopy(observation["inventory"])
+    plan = get_plan(observation)
+    # get action
+    if plan is None or len(plan) == 0:
+        return [[str(StopAction())]], []
+    # plan_recipe, new_inventory = plan[0]
+    subplans = []
+    # Calculate the subplans for each step in the plan
+    for plan_recipe, new_inventory in plan:
+        subplan, current_inventory = decompose_subgoal(
+            current_inventory, plan_recipe, new_inventory
+        )
+        subplans.append(subplan)
+    return subplans, plan

plancraft/environment/sampler.py

@@ -5,17 +5,10 @@ from collections import Counter
 import numpy as np
 from loguru import logger
 
-from plancraft.environment.items import ALL_ITEMS, all_data
-from plancraft.environment.planner import get_ancestors, optimal_planner
+from plancraft.environment.items import ALL_ITEMS
+from plancraft.environment.planner import get_ancestors, optimal_planner, MAX_STACK_SIZE
 from plancraft.environment.recipes import RECIPES
 
-MAX_STACK_SIZE = {}
-for data_item in all_data["items"]:
-    if data_item["stackable"]:
-        MAX_STACK_SIZE[data_item["type"]] = data_item["stackSize"]
-    else:
-        MAX_STACK_SIZE[data_item["type"]] = 1
-
 
 def sample_distractors(
     exclude_set: set = None, num_distractors: int = 16

plancraft/models/oracle.py

@@ -1,108 +1,17 @@
-import copy
-from collections import Counter
-
 import torch
 
 from plancraft.config import EvalConfig
-from plancraft.environment.actions import (
-    MoveAction,
-    SmeltAction,
-    StopAction,
-)
-from plancraft.environment.planner import optimal_planner
-from plancraft.environment.recipes import (
-    ShapedRecipe,
-    ShapelessRecipe,
-    SmeltingRecipe,
-    id_to_item,
-)
-from plancraft.environment.sampler import MAX_STACK_SIZE
+from plancraft.environment.planner import get_subplans
 from plancraft.models.base import PlancraftBaseModel
 from plancraft.models.bbox_model import IntegratedBoundingBoxModel
 
 
-def item_set_id_to_type(item_set_ids: set[int]):
-    return set(id_to_item(i) for i in item_set_ids)
-
-
-def find_free_inventory_slot(inventory: dict, from_slot: int) -> int:
-    # find a free slot in the inventory for the item in from_slot
-    from_item_type = inventory[from_slot]["type"]
-    from_item_quantity = inventory[from_slot]["quantity"]
-
-    empty_slots = set(range(10, 46)) - set(inventory.keys()) - set([from_slot])
-
-    type_to_slot = {}
-    slot_to_quantity = {}
-    for slot, item in inventory.items():
-        if slot == from_slot:
-            continue
-        item_type = item["type"]
-        if item_type not in type_to_slot:
-            type_to_slot[item_type] = [slot]
-        else:
-            type_to_slot[item_type].append(slot)
-
-        slot_to_quantity[slot] = item["quantity"]
-
-    assert from_item_type is not None, f"Item not found in slot {from_slot}"
-
-    # if there is a free slot with the same item type
-    if from_item_type in type_to_slot:
-        for slot in type_to_slot[from_item_type]:
-            if (
-                slot_to_quantity[slot] + from_item_quantity
-                <= MAX_STACK_SIZE[from_item_type]
-            ):
-                return slot
-    if len(empty_slots) > 0:
-        return empty_slots.pop()
-
-    raise ValueError("No free slot found")
-
-
-def find_item_in_inventory(target: str, inventory: dict) -> int:
-    for slot, item in inventory.items():
-        if item["type"] == target and item["quantity"] > 0:
-            return slot
-
-
-def get_inventory_counter(inventory: dict) -> Counter:
-    counter = Counter()
-    for slot, item in inventory.items():
-        if slot == 0:
-            continue
-        counter[item["type"]] += item["quantity"]
-    return counter
-
-
-def get_crafting_slot_item(inventory: dict) -> dict:
-    for slot, item in inventory.items():
-        if slot == 0 and item["quantity"] > 0:
-            return item
-    return None
-
-
-def update_inventory(
-    inventory: dict, slot_from: int, slot_to: int, quantity: int
-) -> dict:
-    """
-    decrements quantity of item in slot_from
-    NOTE: we don't care about incrementing the items in slot_to
-
-    """
-    new_inventory = dict(inventory)
-    new_inventory[slot_from]["quantity"] -= quantity
-    return new_inventory
-
-
 class OracleModel(PlancraftBaseModel):
     """
     Oracle model returns actions that solve the task optimally
     """
 
     def __init__(self, cfg: EvalConfig):
-        self.plans = []
         self.subplans = []
         self.use_fasterrcnn = cfg.plancraft.use_fasterrcnn
 
@@ -117,118 +26,15 @@ class OracleModel(PlancraftBaseModel):
                 self.bbox_model.cuda()
 
     def reset(self):
-        self.plans = []
-        self.subplans = []
-
-    def get_plan(self, observation: dict):
-        # this simply recovering the target item to craft
-        inventory_counter = get_inventory_counter(observation["inventory"])
-        return optimal_planner(
-            target=observation["target"], inventory=inventory_counter
-        )
-
-    def get_next_action(self, observation: dict) -> MoveAction | SmeltAction:
-        if len(self.subplans) > 0:
-            return self.subplans.pop(0)
-        if len(self.plans) == 0:
-            raise ValueError("No more steps in plan")
-
-        if self.bbox_model is not None:
-            observed_inventory = self.bbox_model.get_inventory(
-                observation["image"].copy()
-            )
-        else:
-            observed_inventory = copy.deepcopy(observation["inventory"])
-
-        # take item from crafting slot
-        if slot_item := get_crafting_slot_item(observed_inventory):
-            # move item from crafting slot to inventory
-            free_slot = find_free_inventory_slot(observed_inventory, from_slot=0)
-            return MoveAction(
-                slot_from=0, slot_to=free_slot, quantity=slot_item["quantity"]
-            )
-
-        plan_recipe, new_inventory = self.plans.pop(0)
         self.subplans = []
-        new_inventory_counter = Counter(new_inventory)
-        current_inventory = observed_inventory
-        current_inventory_counter = get_inventory_counter(current_inventory)
-        items_to_use_counter = current_inventory_counter - new_inventory_counter
-        new_items = new_inventory_counter - current_inventory_counter
-        if not self.use_fasterrcnn:
-            assert len(new_items) == 1
-
-        if isinstance(plan_recipe, ShapelessRecipe):
-            crafting_slot = 1
-            # add each item to crafting slots
-            for item, quantity in items_to_use_counter.items():
-                n = 0
-                while n < quantity:
-                    from_slot = find_item_in_inventory(item, current_inventory)
-
-                    # skip if from_slot is the crafting slot
-                    if from_slot == crafting_slot:
-                        crafting_slot += 1
-                        n += 1
-                        continue
-
-                    action = MoveAction(
-                        slot_from=from_slot, slot_to=crafting_slot, quantity=1
-                    )
-                    # update state of inventory
-                    current_inventory = update_inventory(
-                        current_inventory, from_slot, crafting_slot, 1
-                    )
-                    self.subplans.append(action)
-                    crafting_slot += 1
-                    n += 1
-
-        # if plan_recipe is a smelting recipe
-        elif isinstance(plan_recipe, SmeltingRecipe):
-            assert len(items_to_use_counter) == 1, "smelting only supports one item"
-            for item, quantity in items_to_use_counter.items():
-                from_slot = find_item_in_inventory(item, current_inventory)
-                free_slot = find_free_inventory_slot(
-                    current_inventory, from_slot=from_slot
-                )
-                action = SmeltAction(
-                    slot_from=from_slot, slot_to=free_slot, quantity=quantity
-                )
-                self.subplans.append(action)
-
-        # if plan_recipe is a shaped recipe
-        elif isinstance(plan_recipe, ShapedRecipe):
-            for i, row in enumerate(plan_recipe.kernel):
-                for j, item_set in enumerate(row):
-                    inventory_position = (i * 3) + j + 1
-                    valid_items = item_set_id_to_type(item_set)
-                    for item in valid_items:
-                        if items_to_use_counter[item] > 0:
-                            from_slot = find_item_in_inventory(item, current_inventory)
-                            action = MoveAction(
-                                slot_from=from_slot,
-                                slot_to=inventory_position,
-                                quantity=1,
-                            )
-                            items_to_use_counter[item] -= 1
-                            # update state of inventory
-                            current_inventory = update_inventory(
-                                current_inventory, from_slot, inventory_position, 1
-                            )
-                            self.subplans.append(action)
-                            break
-        else:
-            raise NotImplementedError(f"Recipe type {type(plan_recipe)} not supported")
-
-        return self.subplans.pop(0)
 
     def step(self, observation: dict, **kwargs) -> str:
         # get action
-        if len(self.plans) == 0:
-            self.plans = self.get_plan(observation)
-            if self.plans is None:
-                self.plans = []
-                return str(StopAction())
-
-        action = self.get_next_action(observation)
-        return str(action)
+        if len(self.subplans) == 0:
+            subplans, _ = get_subplans(observation)
+            # flatten subplans since they are nested for each subgoal
+            flattened_subplans = [item for sublist in subplans for item in sublist]
+            self.subplans = flattened_subplans
+
+        action = self.subplans.pop(0)
+        return action

{plancraft-0.3.14.dist-info → plancraft-0.3.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plancraft
-Version: 0.3.14
+Version: 0.3.16
 Summary: Plancraft: an evaluation dataset for planning with LLM agents
 License: MIT License
         

{plancraft-0.3.14.dist-info → plancraft-0.3.16.dist-info}/RECORD

@@ -14,10 +14,10 @@ plancraft/environment/__init__.py,sha256=XFsFny4lH195AwAmL-WeCaF9ZCMgc7IgXIwhQ8F
 plancraft/environment/actions.py,sha256=AQxFaK4YW53mPwhuPhHrDF9wENSVjPHSWk0v77I1thw,9460
 plancraft/environment/env.py,sha256=A4532st7JFBYBF_Nh0CEEi3ZTLJAeaB3t9PAIVSemj0,16390
 plancraft/environment/items.py,sha256=Z9rhSyVDEoHF1pxRvhyiT94tyQJaWHi3wUHVcamz82o,221
-plancraft/environment/planner.py,sha256=eJExz3OxSzurIEdH9LOtMwFH9ApqMQ3CokVhmbV6Px0,3953
+plancraft/environment/planner.py,sha256=uIOJjIoyT_4pxeWeTKb8BkLJyKZG0-AMoEOkZs6Ua9A,19340
 plancraft/environment/prompts.py,sha256=8QXclX0ygpL02uZichE1AVkbdn_0HGteD5bzo0FZGOU,6947
 plancraft/environment/recipes.py,sha256=0vwzOU86eZmGN2EpZVSIvzxpx0AOBWNPxTtAOFBN2A0,19570
-plancraft/environment/sampler.py,sha256=lTSiGfmrew0G7ewOWtz6dtt58Mj0rAg6PW8BIbBegXA,7646
+plancraft/environment/sampler.py,sha256=79hLpTU0ajvMPoBsvSe8tE88x31c8Vlczb3tJZJcau0,7441
 plancraft/environment/search.py,sha256=Dmdvj04kMvPlwvoWSc2261LTXV8RbMpS4FODV1YoZKs,1847
 plancraft/environment/assets/constants.json,sha256=kyOIOh82CTTMMGEIS60k5k6M-6fkEmYDoGAnvi3Zx5k,1379016
 plancraft/environment/assets/minecraft_font.ttf,sha256=AzoK9cgggXwjFPHtIO7uz-YaDrminl3nvB-VsaTvTAk,60992
@@ -1917,10 +1917,10 @@ plancraft/models/base.py,sha256=uhG1tRmsBerJzW8qHoLyLEYpveDv0co7AAhi4mSfyO4,661
 plancraft/models/bbox_model.py,sha256=3b1IEspoHiVUR6GOWjEbp4YoxRhGkzKt-eOiwaN8NXo,17091
 plancraft/models/dummy.py,sha256=856oEX6NquXSIIfQLTEFFeB8ib7VUUs5cB0TVHAiFvI,1248
 plancraft/models/generators.py,sha256=F76_iPiqxUjDIrQwF58tzM0bLM91OkZJ0sBqBuki5wY,13939
-plancraft/models/oracle.py,sha256=jDCE6zVFvbwFpDzQZTkHIlRwMud1yMJ4LVIdfpt5ddU,8449
+plancraft/models/oracle.py,sha256=tMp9mTwD70T3qohj-LZhJFjHYWyiVHDh8gu27asVimI,1342
 plancraft/models/utils.py,sha256=E-sZohvolWgGbpHQKgAgkgIfUJoVnT5pMt6JP8xLHKg,4034
 plancraft/train/dataset.py,sha256=oFqEd4LG9oEQ-71teh0Wf7-jJbtybT2ZibfM2bBdBkM,5474
-plancraft-0.3.14.dist-info/METADATA,sha256=2LWU4DAq1vYAlcWLU_c3AAbVkqoyHWRJ6EFiMCtF2jM,11148
-plancraft-0.3.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plancraft-0.3.14.dist-info/licenses/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
-plancraft-0.3.14.dist-info/RECORD,,
+plancraft-0.3.16.dist-info/METADATA,sha256=FIfCMBzCVuDWFCf5cPPKXLdm1EHbgKRpQ2eT5khTMN0,11148
+plancraft-0.3.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plancraft-0.3.16.dist-info/licenses/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
+plancraft-0.3.16.dist-info/RECORD,,