updatE

prompts/data/base_assets.json

@@ -0,0 +1,52 @@
+{
+    "stacking": [
+        "stacking/block.urdf",
+        "stacking/stand.urdf"
+    ],
+    "corner": [
+        "corner/corner-template.urdf"
+    ],
+    "ball": [
+        "ball/ball-template.urdf",
+        "ball/ball.urdf"
+    ],
+    "sphere": [
+        "sphere/sphere.urdf",
+        "sphere/sphere-template.urdf"
+    ],
+    "zone": [
+        "zone/zone.urdf",
+        "zone/zone.obj"
+    ],
+    "block": [
+        "block/block.urdf",
+        "block/block_for_anchors.urdf",
+        "block/small.urdf"
+    ],
+    "pallet": [
+        "pallet/pallet.urdf",
+        "pallet/pallet.obj"
+    ],
+    "cylinder": [
+        "cylinder/cylinder-template.urdf"
+    ],
+    "container": [
+        "container/container-template.urdf"
+    ],
+    "bowl": [
+        "bowl/bowl.urdf"
+    ],
+    "square": [
+        "square/square-template.urdf"
+    ],    
+    "box": [
+        "box/box-template.urdf"
+    ],
+    "line": [
+        "line/line-template.urdf"
+    ],    
+    "insertion": [
+        "insertion/ell.urdf",
+        "insertion/fixture.urdf"
+    ]
+}

prompts/data/base_task_codes.json

@@ -0,0 +1 @@
+["align_box_corner.py", "align_rope.py", "assembling_kits.py",  "block_insertion.py", "manipulating_rope.py", "packing_boxes.py", "align_rope.py", "packing_boxes_pairs.py", "palletizing_boxes.py", "place_red_in_green.py", "put_block_in_bowl.py", "separating_piles.py", "stack_block_pyramid.py",  "sweeping_piles.py", "towers_of_hanoi.py"]

prompts/data/base_tasks.json

@@ -0,0 +1,32 @@
+{
+"sweeping-piles": {"assets-used": ["zone/zone.urdf", "block/small.urdf"],
+ "task-description": "Push piles of small objects into a target goal zone marked on the tabletop.",
+ "task-name": "sweeping-piles"},
+"place-red-in-green": {"assets-used": ["bowl/bowl.urdf", "stacking/block.urdf"],
+ "task-description": "pick up the red blocks and place them into the green bowls amidst other objects.",
+ "task-name": "place-red-in-green"},
+"align-box-corner": {"assets-used": ["box/box-template.urdf", "corner/corner-template.urdf"],
+ "task-description": "pick up the randomly sized box and align one of its corners to the L-shaped marker on the tabletop..",
+ "task-name": "align-box-corner"},
+"stack-block-pyramid": {"assets-used": ["stacking/stand.urdf", "stacking/block.urdf"],
+ "task-description": "sequentially stack 6 blocks into a pyramid of 3-2-1 with rainbow colored ordering.",
+ "task-name": "stack-block-pyramid"},
+"palletizing-boxes": {"assets-used": ["pallet/pallet.urdf", "box/box-template.urdf"],
+ "task-description": "pick up homogeneous fixed-sized boxes and stack them in transposed layers on the pallet.",
+ "task-name": "palletizing-boxes"},
+"assembling-kits": {"assets-used": ["kitting/kit.urdf", "kitting/object-template.urdf"],
+ "task-description": "pick up different objects and arrange them on a board marked with corresponding silhouettes.",
+ "task-name": "assembling-kits"},
+"packing-boxes": {"assets-used": ["container/container-template.urdf", "box/box-template.urdf"],
+ "task-description": "pick up randomly sized boxes and place them tightly into a container.",
+ "task-name": "packing-boxes"},
+"sweeping-piles": {"assets-used": ["zone/zone.urdf", "block/small.urdf"],
+ "task-description": "push piles of small objects into a target goal zone marked on the tabletop.",
+ "task-name": "sweeping-piles"},
+"manipulating-rope": {"assets-used": ["square/square-template.urdf"],
+ "task-description": "rearrange a deformable rope such that it connects the two endpoints of a 3-sided square.",
+ "task-name": "manipulating-rope"},
+"align-rope": {"assets-used": ["square/square-template.urdf"],
+ "task-description": "manipulate a deformable rope to connect its end-points between two corners of a 3-sided square.",
+ "task-name": "align-rope"}
+}

prompts/data/generated_assets.json

@@ -0,0 +1,2 @@
+{
+}

prompts/data/generated_task_codes.json

@@ -0,0 +1,140 @@
+[
+    "build_wheel.py",
+    "rainbow_stack.py",
+    "push-piles_into_letter.py",
+    "connect_boxes_with_rope.py",
+    "build_car.py",
+    "manipulating_two_ropes.py",
+    "insert_sphere_into_container.py",
+    "insert_cylinder_in_container.py",
+    "build_bridge.py",
+    "insert_ell_in_fixture.py",
+    "build_block_tower_on_pallet.py",
+    "color_coordinated_tower.py",
+    "stack_blocks_in_container.py",
+    "mix_piles.py",
+    "insert_blocks_into_fixture.py",
+    "color_coordinated_block_tower.py",
+    "color_structured_block_tower.py",
+    "stack_color_coordinated_blocks.py",
+    "assemble_single_car.py",
+    "sort_and_stack_clr_blocks.py",
+    "create_pyramid_blocks_and_container.py",
+    "Four_corner_pyramid_challenge.py",
+    "colorful_block_tower_on_cylinder_base.py",
+    "align_cylinders_in_square.py",
+    "corner_block_challenge.py",
+    "construct_corner_blocks.py",
+    "corner_sort_cylinders.py",
+    "sorting_blocks_into_pallets.py",
+    "sort_and_assemble_block_castle.py",
+    "vertical_insertion_blocks.py",
+    "color_coordinated_sphere_insertion.py",
+    "block_pyramid_with_limited_space.py",
+    "build_cylinder_structure.py",
+    "insert_blocks_lineup.py",
+    "color_specific_container_fill.py",
+    "multicolor_block_bridge.py",
+    "pyramid_blocks_assemble.py",
+    "triangle_block_arrangement.py",
+    "place_ball_in_elevated_bowl.py",
+    "align_balls_in_colored_zones.py",
+    "color_coordinated_cylinder_tower.py",
+    "symmetric_block_bridge_construction.py",
+    "sphere_align_stand.py",
+    "construct_colorful_arch.py",
+    "color_sorted_container_stack.py",
+    "align_spheres_in_colored_zones.py",
+    "sort_insert_color_coordinated_blocks.py",
+    "color_ordered_insertion.py",
+    "color_coordinated_cylinders_in_boxes.py",
+    "color_coordinated_insertion.py",
+    "cylinder_stand_alignment.py",
+    "color_coordinated_container_sorting.py",
+    "color_sorted_block_race.py",
+    "multi_level_block_construction.py",
+    "color_linked_ball_bowl_ordering.py",
+    "color_blocks_in_cylinder_maze.py",
+    "create_pyramid_with_color_coded_ells.py",
+    "move_piles_along_line.py",
+    "color_ordered_blocks_on_pallet.py",
+    "color_ordered_container_arrangement.py",
+    "multi_level_pyramid_construction.py",
+    "align_balls_in_colored_boxes.py",
+    "color_coordinated_pyramid_in_container.py",
+    "colored_balls_sorting_in_corner.py",
+    "color_coordinated_ball_insertion.py",
+    "color_sequenced_pyramid_packing.py",
+    "color_block_ball_goal.py",
+    "ball_sorting_with_blocks_barrier.py",
+    "color_matched_blocks_insertion.py",
+    "color_coordinated_block_bridge.py",
+    "insert_red_block_into_cylinder.py",
+    "color_sequential_ball_container_sorting.py",
+    "color_coordinated_cylinder_pyramid.py",
+    "cylinder_sorting_with_zone.py",
+    "color_coordinated_ball_placement.py",
+    "sweep_and_sort_blocks.py",
+    "align_cylinders_in_zones.py",
+    "sphere_container_color_match.py",
+    "insertion_and_color_sorting.py",
+    "color_coordinated_cylinder_stack.py",
+    "color_coordinated_container_insertion.py",
+    "color_coordinated_insertion_in_container.py",
+    "insert_ell_along_square_path.py",
+    "color_ordered_insertion_with_blocking_boxes.py",
+    "color_coordinated_box_ball_matching.py",
+    "color_coordinated_pallet_pyramid.py",
+    "color_coordinated_ball_insertion_in_boxes.py",
+    "cylinder_balancing_and_placement.py",
+    "align_spheres_in_boxes.py",
+    "color_coordinated_sphere_and_cylinder_assembly.py",
+    "color_coordinated_cylinder_bowl_sorting.py",
+    "sequential_block_insertion.py",
+    "sequential_insertion_and_stacking.py",
+    "color_coordinated_block_shifting.py",
+    "color_coordinated_cylinder_placement_on_pallet.py",
+    "guided_block_path.py",
+    "color_ordered_insertion_with_obstacles.py",
+    "color_matched_block_transfer.py",
+    "mixed_color_block_barrier_insertion.py",
+    "ball_in_bowl_obstacle_course.py",
+    "color_coordinated_bowl_ball_pyramid.py",
+    "color_coordinated_arch_construction.py",
+    "color_coordinated_zone_arrangement.py",
+    "color_coordinated_cylinder_stand_assembly.py",
+    "color_coordinated_cylinder_stand_in_line.py",
+    "color_coordinated_pyramid_construction.py",
+    "color_coordinated_ball_stacking.py",
+    "color_coded_blocks_on_corner.py",
+    "insertion_in_color_sequenced_zones.py",
+    "precise_block_placement_in_container.py",
+    "color_coordinated_bowl_stacking.py",
+    "color_coordinated_zone_stacking.py",
+    "color_cued_ball_insertion.py",
+    "color_coordinated_insertion_through_box_barrier.py",
+    "color_coordinated_insertion_and_stacking.py",
+    "color_coordinated_cylinder_ball_match.py",
+    "multi_level_insertion_and_zone_matching.py",
+    "multi_color_block_sequence_insertion.py",
+    "ball_tower_in_zones.py",
+    "color_coordinated_container_pyramid.py",
+    "corner_blocks_insertion.py",
+    "color_coordinated_insertion_in_cylinders.py",
+    "color_coordinated_block_transport.py",
+    "color_cued_ball_corner_sorting.py",
+    "color_coordinated_insertion_and_corner_pyramid.py",
+    "color_coordinated_sphere_and_cylinder_stack.py",
+    "color_coordinated_blocks_in_cylindrical_maze.py",
+    "color_coordinated_cylinder_relay.py",
+    "color_coordinated_cylinder_maze.py",
+    "insertion_path_obstacle_course.py",
+    "color_coordinated_sphere_and_bowl_match.py",
+    "color_coordinated_pallet_insertion.py",
+    "color_coordinated_insertion_and_stack.py",
+    "cylinder_ring_stack.py",
+    "color_coordinated_sphere_on_pallet_pyramid.py",
+    "color_coordinated_stacked_block_bowls.py",
+    "color_sequenced_sphere_placement.py",
+    "color_sequence_loading_pallet.py"
+]

prompts/data/generated_tasks.json

@@ -0,0 +1,1139 @@
+{
+    "insert-sphere-into-container": {
+        "task-name": "insert-sphere-into-container",
+        "task-description": "Pick up a blue sphere and place it into an open container.",
+        "assets-used": [
+            "sphere/sphere.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "cylinder-container-sorting": {
+        "task-name": "cylinder-container-sorting",
+        "task-description": "Pick up cylindrical blocks of three different colors (red, green, and blue) and place them into three separate containers of matching color.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "insert-cylinder-in-container": {
+        "task-name": "insert-cylinder-in-container",
+        "task-description": "Pick up a blue cylindrical block and place it into an empty container.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "build-car": {
+        "task-name": "build-car",
+        "task-description": "Construct a simple car structure using blocks and cylinders.",
+        "assets-used": [
+            "block/block.urdf",
+            "ball/ball-template.urdf"
+        ]
+    },
+    "build-bridge": {
+        "task-name": "build-bridge",
+        "task-description": "Construct a bridge using two yellow blocks and three blue blocks. Firstly, place the two yellow blocks on each of the two bases parallel to each other with a fair amount of space in between. Then, place the blue block horizontally on top of the yellow blocks.",
+        "assets-used": [
+            "block/block.urdf",
+            "ball/ball-template.urdf"
+        ]
+    },
+    "build-wheel": {
+        "task-name": "build-wheel",
+        "task-description": "Construct a wheel using blocks and a sphere. First, position eight blocks in a circular layout on the tabletop. Each block should be touching its two neighbors and colored in alternating red and blue. Then place a green sphere in the center of the circular layout, completing the wheel.",
+        "assets-used": [
+            "block/block.urdf",
+            "sphere/sphere.urdf"
+        ]
+    },
+    "build-two-circles": {
+        "task-name": "build-two-circles",
+        "task-description": "construct two distinct circles on the tabletop using 6 red and 6 blue blocks",
+        "assets-used": [
+            "block/block.urdf"
+        ]
+    },
+    "manipulating-two-ropes": {
+        "task-name": "manipulating-two-ropes",
+        "task-description": "rearrange the red and blue deformable ropes such that it connects the two endpoints of a 3-sided square of corresponding color.",
+        "assets-used": [
+            "square/square-template.urdf"
+        ]
+    },
+    "insert-ell-in-fixture": {
+        "task-name": "insert-ell-in-fixture",
+        "task-description": "Pick up an Ell shaped block and insert it into a fixture on the tabletop.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "build-block-tower-on-pallet": {
+        "task-name": "build-block-tower-on-pallet",
+        "task-description": "Pick up six blocks in two colors (three red and three blue) and stack them in alternating colors on the pallet. The tower should start with a red block at the bottom.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "color-coordinated-tower": {
+        "task-name": "color-coordinated-tower",
+        "task-description": "Pick up blocks of five different colors (red, blue, green, yellow, and orange) and stack them on a pallet in the specific sequence. The bottom of the tower should start with a red block followed by a blue, green, yellow and finally an orange block at the top.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "stack-blocks-in-container": {
+        "task-name": "stack-blocks-in-container",
+        "task-description": "Pick up five blocks of different colors (red, blue, green, yellow, and orange) and stack them in a container in a specific sequence. The bottom of the stack should start with a red block followed by a blue, green, yellow and finally an orange block at the top.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "insert-blocks-into-fixture": {
+        "task-name": "insert-blocks-into-fixture",
+        "task-description": "Pick up four colored blocks (red, blue, green, and yellow) and insert them one-by-one into a fixture on the tabletop. The order of insertion starts with the red block, followed by the blue, green, and lastly the yellow block.",
+        "assets-used": [
+            "block/block.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-coordinated-block-tower": {
+        "task-name": "color-coordinated-block-tower",
+        "task-description": "On a tabletop, there are fifteen blocks of three different colors (five red, five blue, and five green). The task is to pick up these blocks and stack them onto three different stands on the table, creating three different towers. Each stand should have a tower of the same color blocks with five blocks each. The blocks in each tower should be stacked in a way that the block on top is slightly displaced in relation to the block underneath, creating a spiral-like effect. The challenge lies in the color-based sorting, precise placement for achieving the spiral effect and careful stacking of the blocks to avoid toppling.",
+        "assets-used": [
+            "block/block.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-structured-block-tower": {
+        "task-name": "color-structured-block-tower",
+        "task-description": "Construct a tower using six blocks: two red, two blue, and two green. The tower should be built in the order of a red block at the base, followed by a blue, then green, then red, blue and green at the top.",
+        "assets-used": [
+            "block/block.urdf"
+        ]
+    },
+    "stack-color-coordinated-blocks": {
+        "task-name": "stack-color-coordinated-blocks",
+        "task-description": "Pick up six blocks of different colors (red, blue, green, yellow, orange, and purple) and stack them on a pallet in two separate stacks. The first stack should be red at the bottom, blue in the middle, and green at top. The second stack should be yellow at the bottom, orange in the middle, and purple at the top.",
+        "assets-used": [
+            "box/box-template.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "assemble-single-car": {
+        "task-name": "assemble-single-car",
+        "task-description": "Build a mini car using a large blue box as the body, a smaller red box on top as the roof, and two tiny green boxes on the sides as wheels.",
+        "assets-used": [
+            "box/box-template.urdf"
+        ]
+    },
+    "sort-and-stack-clr-blocks": {
+        "task-name": "sort-and-stack-clr-blocks",
+        "task-description": "Pick up four blocks of different colors (red, blue, green, yellow) and place them into separate corners of a pallet. After sorting, stack them in a specific sequence on top of the pallet. The bottom of the stack should start with a green block followed by a blue, then red, and finally a yellow block at the top.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "create-pyramid-blocks-and-container": {
+        "task-name": "create-pyramid-blocks-and-container",
+        "task-description": "Create a pyramid structure using six blocks of three different colors (two red, two green, and two blue) inside a container. The first layer of the pyramid should consist of the two green and one blue block. The second layer should be the two red blocks, and the last block which is the top of the pyramid should be the remaining blue block.",
+        "assets-used": [
+            "container/container-template.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "Four-corner-pyramid-challenge": {
+        "task-name": "Four-corner-pyramid-challenge",
+        "task-description": "A tabletop is partitioned into four different zones using the 'zone/zone.urdf' asset. In each zone, there are four blocks of different colors (red, blue, green, and yellow). The task is to construct a pyramid of blocks in each zone using the 'block/block.urdf' asset such that the sequence of blocks from bottom to top is red, blue, green, and yellow. The task is challenging because it requires precise stack control and color recognition.",
+        "assets-used": [
+            "block/block.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "colorful-block-tower-on-cylinder-base": {
+        "task-name": "colorful-block-tower-on-cylinder-base",
+        "task-description": "Construct a tower using four blocks of different colors (red, blue, green, and yellow) on a placed cylindrical base at the corner of the tabletop. The sequence from bottom to top should be red, blue, green, and yellow.",
+        "assets-used": [
+            "block/block.urdf",
+            "corner/corner-template.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "align-cylinders-in-square": {
+        "task-name": "align-cylinders-in-square",
+        "task-description": "Arrange four cylinders of different colors (red, blue, green, yellow) on the corners of a square facing the center. The square is outlined by four zones of matching colors at each corner. The red cylinder should be placed at the red zone and facing the center of the square, and same for the remaining colors.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "construct-corner-blocks": {
+        "task-name": "construct-corner-blocks",
+        "task-description": "Create a corner structure using four blocks. Two red blocks form the base, one on each side of the corner, followed by a green block that is positioned on the red blocks at the corner junction, and finally a blue block on top of the green one. The overall structure forms a 3-D corner.",
+        "assets-used": [
+            "block/block.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "corner-sort-cylinders": {
+        "task-name": "corner-sort-cylinders",
+        "task-description": "Pick up cylinders of four different colors (red, blue, green, yellow) and place them into four corners accordingly marked on the tabletop. The corner is designed as a 2-block-size square where only one cylinder can fit. The task is challenging due to precise placement and the need for identifying the corners accurately.",
+        "assets-used": [
+            "corner/corner-template.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "sorting-blocks-into-pallets": {
+        "task-name": "sorting-blocks-into-pallets",
+        "task-description": "Pick up blocks of four different colors (red, blue, green, yellow) and place them into four separate pallets of matching color. The pallets are placed in a row and the blocks are scattered randomly on the table.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "sort-and-assemble-block-castle": {
+        "task-name": "sort-and-assemble-block-castle",
+        "task-description": "On a tabletop, there are twelve blocks of three different colors (four red, four green, and four blue). The task involves sorting the blocks according to the color in three marked zones on the tabletop and subsequently constructing a castle in each zone. In each castle, the first layer should consist of the two blocks of the same color, followed by the second layer of one block and finally the last block on the top forming a castle-like structure. The challenge lies in the color-based sorting and careful assembly of the blocks to avoid toppling.",
+        "assets-used": [
+            "block/block.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "push-piles-into-letter": {
+        "task-name": "push-piles-into-letter",
+        "task-description": "Push piles of small objects into a target goal zone shaped in some letters.",
+        "assets-used": [
+            "kitting/kit.urdf",
+            "kitting/object-template-nocollision.urdf"
+        ]
+    },
+    "connect-boxes-with-rope": {
+        "task-name": "connect-boxes-with-rope",
+        "task-description": "Connect two colored blocks with ropes.",
+        "assets-used": [
+            "block/block.urdf"
+        ]
+    },
+    "vertical-insertion-blocks": {
+        "task-name": "vertical-insertion-blocks",
+        "task-description": "The task involves picking up four color specific blocks (red, blue, green, and yellow) and inserting each block into four differently colored stands set upright on the tabletop. The block-colored with red needs to be inserted into the red-colored stand, and the same sequence is maintained for each colored blocks and stands. This task is challenging due to the requirement for precise insertion and the manipulation of vertical objects.",
+        "assets-used": [
+            "stacking/block.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-sphere-insertion": {
+        "task-name": "color-coordinated-sphere-insertion",
+        "task-description": "There are four spheres and four boxes of different colors (red, blue, green, and yellow). Each sphere is inside a box, but not corresponding to the color of the box. The task is to pick up each sphere and place it in the box of the same color. The challenge lies in the precise placement and color matching.",
+        "assets-used": [
+            "sphere/sphere.urdf",
+            "box/box-template.urdf"
+        ]
+    },
+    "block-pyramid-with-limited-space": {
+        "task-name": "block-pyramid-with-limited-space",
+        "task-description": "On a tabletop, there are twelve blocks of four different colors (three red, three green, three blue, three yellow). Three zones are defined, each with a triangle-shaped border that is marked. The task involves sorting the blocks according to the color into three zones on the tabletop and constructing a pyramid in each zone. In each pyramid, the base should contain two blocks of the same color, followed by the second layer of one block, thus forming a pyramid-like structure. However, the third yellow block should be placed in the center of the zones forming a smaller pyramid. The challenge lies in the color-based sorting, careful assembly of the blocks to avoid topple, and limited space in the zones which adds to the complexity.",
+        "assets-used": [
+            "block/block.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "build-cylinder-structure": {
+        "task-name": "build-cylinder-structure",
+        "task-description": "Using four colored cylinders (red, blue, green, yellow), construct a structure atop a square base. The red and blue cylinders should be sealed by the square base side by side, while the green cylinder should be on top of the blue one, and the yellow one on top of the red. The final look should resemble the letter 'H'.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "insert-blocks-lineup": {
+        "task-name": "insert-blocks-lineup",
+        "task-description": "On the tabletop, there are four different color blocks (red, blue, green, and yellow), and four fixtures in corresponding colors. The task is to pick up each block and insert it into the corresponding color fixture. However, the fixtures are arranged in a straight line, with a line of small blocks serving as barrier between the fixtures and the colored blocks initially scattered on the table, providing a challenge in precise navigation and placement.",
+        "assets-used": [
+            "block/block.urdf",
+            "insertion/fixture.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-specific-container-fill": {
+        "task-name": "color-specific-container-fill",
+        "task-description": "Arrange four colored blocks (red, blue, green, and yellow) around a pallet. Then, pick up these blocks and place them inside a container marked in the same color. The task requires precise placement, color matching, and an understanding of spatial structures.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "multicolor-block-bridge": {
+        "task-name": "multicolor-block-bridge",
+        "task-description": "Build a bridge by stacking three red, three blue, and three green blocks on a pallet. Arrange in a sequence from left to right: red, blue, and green. Then, place three cylinders of corresponding colors on top of the stacked blocks, forming a bridge. The cylinders should roll from the top block to the pallet, creating a challenge of precision and control.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "pyramid-blocks-assemble": {
+        "task-name": "pyramid-blocks-assemble",
+        "task-description": "Construct a pyramid using nine blocks in a specific color order on a pallet. The bottom layer should contain five blocks: red, blue, green, yellow, and orange (in that order from left to right). The middle layer should consist of three blocks: yellow, red, and blue (from left to right). The top layer should contain a single green block. The pyramid requires careful placement and color matching.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "triangle-block-arrangement": {
+        "task-name": "triangle-block-arrangement",
+        "task-description": "Arrange blocks of three different colors (red, green, and blue) in a triangular layout on the tabletop. The base of the triangle should consist of three red blocks, followed by a row of two green blocks, and finally a single blue block at the top of the triangle. The task is challenging due to the need for precise placement and color coordination.",
+        "assets-used": [
+            "block/block.urdf"
+        ]
+    },
+    "place-ball-in-elevated-bowl": {
+        "task-name": "place-ball-in-elevated-bowl",
+        "task-description": "The primary objective of the task is to pick up a red ball and carefully place it into a bowl, which is positioned on a raised platform that is surrounded by small blocks. The challenge lies in precise navigation, maintaining a hold of the ball, and avoiding the surrounding blocks.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "bowl/bowl.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "align-balls-in-colored-zones": {
+        "task-name": "align-balls-in-colored-zones",
+        "task-description": "There are six balls of different colors (red, blue, green, yellow, orange, and purple) and six zones correspondingly colored. The task is to pick up each ball and place it in the zone of the same color, arranging the balls in a straight line. The challenge lies in the precise placement and color matching.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-tower": {
+        "task-name": "color-coordinated-cylinder-tower",
+        "task-description": "Stack cylinders of four different colors (red, blue, green, yellow) on top of each other on a square stand in a specific sequence. The bottom of the stack should start with a blue cylinder, follow by a green cylinder, then a red one, and finally a yellow cylinder at the top. Each cylinder has to be aligned correctly to avoid falling.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "symmetric-block-bridge-construction": {
+        "task-name": "symmetric-block-bridge-construction",
+        "task-description": "Create a symmetrical bridge-shaped structure on a stand using eight blocks of two different colors (four red and four blue). Start by placing two red blocks side by side at the center of the stand to form the base of the bridge. Then, take a blue block and place it on top of the red blocks, followed by another red block on top of the blue one, and this pattern continues till you exhaust all the blocks. The final structure should be a bridge with alternating colors (red, blue, red, blue). The challenge lies in ensuring symmetry and balancing the blocks without making them fall.",
+        "assets-used": [
+            "stacking/stand.urdf",
+            "block/block-template.urdf"
+        ]
+    },
+    "sphere-align-stand": {
+        "task-name": "sphere-align-stand",
+        "task-description": "On a table there are five differently colored stands and five spheres. The task involves picking up each sphere and placing it on the stand of the matching color. The task is challenging due to the precision required in picking up and placing the spheres, and the color coordination.",
+        "assets-used": [
+            "stacking/stand.urdf",
+            "sphere/sphere.urdf"
+        ]
+    },
+    "construct-colorful-arch": {
+        "task-name": "construct-colorful-arch",
+        "task-description": "Construct an arch using six blocks: three red, and three blue. Place two red blocks on the tabletop parallel to each other, then place a blue block on top of the red blocks to form a basic arch. Repeat the process by placing a red block on each side of the base arch and bridge them with the last blue block. Finally, place the last two red blocks on top of the second layer of the red blocks, on either side. The overall structure forms a colorful 3D arch.",
+        "assets-used": [
+            "block/block.urdf"
+        ]
+    },
+    "color-sorted-container-stack": {
+        "task-name": "color-sorted-container-stack",
+        "task-description": "The challenge is to stack four differently colored blocks (red, blue, green, yellow) inside a container. These blocks are initially placed inside two separate bowls. The red and blue blocks are in one bowl, the yellow and green blocks are in another. The robot has to pick up the blocks from the two bowls and stack them inside the container in the specific order: red, blue, green, then yellow.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "container/container-template.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "align-spheres-in-colored-zones": {
+        "task-name": "align-spheres-in-colored-zones",
+        "task-description": "There are four spheres of different colors (red, blue, green, yellow) positioned randomly on the table along with four zones marked with matching colors. The task is to pick up each sphere and place it into the matching colored zone with precise placement.",
+        "assets-used": [
+            "sphere/sphere-template.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "sort-insert-color-coordinated-blocks": {
+        "task-name": "sort-insert-color-coordinated-blocks",
+        "task-description": "There are six blocks of three different colors (two red, two blue, and two green), two red containers, two blue containers, and two green containers scattered on the table. The task is to sort the blocks by their colors and place (insert) them into the containers of the matching color. Two blocks of the same color should go into two different containers of the same color. The challenge lies in the color-based sorting and insertion of the blocks into the containers.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-ordered-insertion": {
+        "task-name": "color-ordered-insertion",
+        "task-description": "There are four differently-colored ell objects (red, blue, green, yellow) and a corresponding set of color-coded fixtures. The task involves picking up each ell object and inserting it into the matching color fixture in a specific order: from left to right, insert red, blue, green, and finally yellow. The challenge lies in the precise manipulation of the ell objects and the color-coordination required. The fixtures are arranged in a straight line, and can only be approached from one direction, demanding careful navigation.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-coordinated-cylinders-in-boxes": {
+        "task-name": "color-coordinated-cylinders-in-boxes",
+        "task-description": "Arrange four cylinders of different colors (red, blue, green, and yellow) into four matching colored boxes, such that each box contains a cylinder of the same color. The task is challenging due to the manipulation of cylindrical objects and the color coordination required.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "box/box-template.urdf"
+        ]
+    },
+    "color-coordinated-insertion": {
+        "task-name": "color-coordinated-insertion",
+        "task-description": "There are three insertion fixtures and three ell shaped blocks of different colors (red, blue, green) on the table top. The task is to pick up the ell shaped blocks and insert each one of them into the fixture of the same color. However, the ell blocks should be inserted in a specific sequence - red first, then blue, and finally green. This task is challenging due to the precision required for insertion and the need for color coordination and sequencing.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "cylinder-stand-alignment": {
+        "task-name": "cylinder-stand-alignment",
+        "task-description": "Arrange four colored cylinders (red, blue, green, yellow) in order of their colors on four stands of matching color. However, the stands are placed in a random order on the table, which increases the complexity of the task as it requires careful planning and color matching.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-container-sorting": {
+        "task-name": "color-coordinated-container-sorting",
+        "task-description": "On the table there are four different colored containers (red, blue, green and yellow) and sixteen blocks of the same four colors (four blocks of each color). The task challenges the robot to pick up these blocks and sort them into the containers of the same color, with each container having one of each color of blocks in it. To make the task interesting, each container should have the blocks in a different order. One container might have them in the order red, blue, green, yellow; another one in the order yellow, green, blue, red; and the last two could have them in the orders green, red, yellow, blue; and blue, yellow, red, green. The robot would need to first identify the correct container for sorting, and then plan the correct order of the blocks.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-sorted-block-race": {
+        "task-name": "color-sorted-block-race",
+        "task-description": "On one end of a tabletop, there are six blocks in two colors (three red and three blue). On the other end of the tabletop, two sets of three small marked zones are arranged in a straight line, one set for blue and one set for red. The task involves picking up one block at a time and placing it in the corresponding colored zone in a sequence from the bottom end zone to the top end zone. The blocks must be placed following the rule: the three colored blocks must be transported consecutively, e.g., first place all three blue blocks and then place all three red blocks. The challenge lies in careful transportation and placement of the blocks and follows the specific rule.",
+        "assets-used": [
+            "block/block.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "multi-level-block-construction": {
+        "task-name": "multi-level-block-construction",
+        "task-description": "Construct a two-level structure on a pallet using four blocks: two red and two blue. The lower level should be a rectangle created by placing the red blocks side by side. The upper level is made up by placing the blue blocks placed on top of the red blocks creating a line aligned perpendicular to the red blocks. The challenge lies in the precise placement of blocks, maintaining balance of the structure, and correct color arrangement.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "color-linked-ball-bowl-ordering": {
+        "task-name": "color-linked-ball-bowl-ordering",
+        "task-description": "On a tabletop, there are four bowls and four balls of different colors (red, blue, green, and yellow). Each ball is inside a bowl, but not corresponding to the color of the bowl. The task is to pick up each ball and place it in the bowl of the same color, in the specific sequence of red, blue, green and yellow from left to right. The challenge lies in the precise placement, color matching and sequence following.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "ball/ball.urdf"
+        ]
+    },
+    "color-blocks-in-cylinder-maze": {
+        "task-name": "color-blocks-in-cylinder-maze",
+        "task-description": "Pick up five differently colored blocks (red, blue, yellow, green, and orange) that are scattered randomly on the table top. Arrange three cylindrical containers in a row to create a maze-like structure. Place the red, yellow, and blue block into the first, second, and third cylinder from left respectively. Then, stack the green and orange block on top of any container, followed by placing the same color palette on the respective block.",
+        "assets-used": [
+            "block/block.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "create-pyramid-with-color-coded-ells": {
+        "task-name": "create-pyramid-with-color-coded-ells",
+        "task-description": "There are four insertion ell-shaped objects ('insertion/ell.urdf') of different colors (red, blue, yellow, and green) placed randomly on the tabletop. The task is to pick up each of these objects and stack them onto a fixed-size pallet in the shape of a pyramid. The order of the pyramid from bottom to top should be red, blue, yellow, and green.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "move-piles-along-line": {
+        "task-name": "move-piles-along-line",
+        "task-description": "Move three piles of small blocks, each pile a different color (red, blue, green), along three matching colored lines to three separate zones of the same color using a spatula.",
+        "assets-used": [
+            "block/small.urdf",
+            "zone/zone.urdf",
+            "line/line-template.urdf"
+        ]
+    },
+    "color-ordered-blocks-on-pallet": {
+        "task-name": "color-ordered-blocks-on-pallet",
+        "task-description": "On a table there are six different colored blocks (red, blue, green, yellow, orange, and purple), a pallet, and a small corner structure. These colored blocks are arranged randomly within the small corner structure. The task involves picking up each colored block and placing it onto the pallet in specific color sequence: red, blue, green, yellow, orange, and finally purple.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "color-ordered-container-arrangement": {
+        "task-name": "color-ordered-container-arrangement",
+        "task-description": "On the tabletop, there are six containers and six blocks of different colors (red, blue, green, yellow, orange, purple). The task is to pick up each block and place it into a container of the same color, then arrange the containers in a line in the following color order: red, blue, green, yellow, orange, and purple.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "multi-level-pyramid-construction": {
+        "task-name": "multi-level-pyramid-construction",
+        "task-description": "Construct a two-level pyramid on a pallet using six blocks: three green and three blue. The first level should be a triangle created by placing the green blocks side by side. The second level should be built by placing the blue blocks on top of the green blocks, forming another triangle rotated 60 degrees with respect to the first one. The challenge lies in the precise placement of blocks, maintaining balance of the structure, and correct color arrangement.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "align-balls-in-colored-boxes": {
+        "task-name": "align-balls-in-colored-boxes",
+        "task-description": "On a tabletop, there are four balls and four boxes of different colors (red, blue, green, and yellow). Each ball is inside a box, but not corresponding to the color of the box. The task is to pick up each ball and place it in the box of the same color, in the specific sequence of red, blue, green and yellow from left to right. The challenge lies in the precise placement, color matching and sequence following.",
+        "assets-used": [
+            "ball/ball.urdf",
+            "box/box-template.urdf"
+        ]
+    },
+    "color-coordinated-pyramid-in-container": {
+        "task-name": "color-coordinated-pyramid-in-container",
+        "task-description": "There are six blocks of three different colors (red, blue, green) and three containers of matching colors. The task involves picking up each color of blocks and placing them in the container of the same color in a pyramid formation, with two blocks at the base and one block on top. The challenge lies in the precise placement of blocks, maintaining balance of the pyramid, and color coordination.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "colored-balls-sorting-in-corner": {
+        "task-name": "colored-balls-sorting-in-corner",
+        "task-description": "There are four balls and four corners of different colors (red, blue, green, and yellow). Each ball is located at a corner, but not corresponding to the color of the corner. The task is to pick up each ball and place it in the corner of the same color, in the specific sequence of red, blue, green and yellow, starting from the leftmost corner to the rightmost. The challenge lies in the precise placement, color matching and sequence following.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "color-coordinated-ball-insertion": {
+        "task-name": "color-coordinated-ball-insertion",
+        "task-description": "There are five differently-colored ell objects (red, blue, green, yellow, orange) and five sphere-shaped containers of matching colors. The task involves picking up each ell object and inserting it into the sphere container of the same color, but in a specific sequence from left to right: red, blue, green, yellow, and finally orange. The task is challenging due to the sequence, color coordination, and accuracy of insertion required.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "sphere/sphere-template.urdf"
+        ]
+    },
+    "color-sequenced-pyramid-packing": {
+        "task-name": "color-sequenced-pyramid-packing",
+        "task-description": "There are twelve cubes of different colors (three red, three green, three blue, and three yellow) scattered on the tabletop. The task is to pick up the cubes, sort them according to color into four pallets, and stack them in each pallet as a pyramid with the base layer containing two cubes and the top layer containing one cube. The challenge lies in the color-based sorting, the precise placement of cubes, and the construction of the pyramid in each pallet.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "color-block-ball-goal": {
+        "task-name": "color-block-ball-goal",
+        "task-description": "On a tabletop, there are four zones marked in four different colors (red, blue, green, and yellow) and four balls of matching colors. The task involves picking up each ball and precisely placing it in the zone of the same color. However, there are several small blocks randomly scattered in the path between the balls and the zones. The robot has to strategically navigate around these blocks without knocking them over while transporting the balls to the corresponding zones. The challenge lies in the precise navigation, placement of the balls, and color matching while avoiding the blocks.",
+        "assets-used": [
+            "zone/zone.urdf",
+            "ball/ball-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "ball-sorting-with-blocks-barrier": {
+        "task-name": "ball-sorting-with-blocks-barrier",
+        "task-description": "On a tabletop, there are four balls and four zones of different colors (red, blue, green, and yellow). Each ball is located behind a line of small blocks of the same color. The task is to pick up each ball and place it into the zone of the same color, but without knocking over the blocks. The challenge lies in the precise navigation over the block barriers and color matching.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "zone/zone.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-matched-blocks-insertion": {
+        "task-name": "color-matched-blocks-insertion",
+        "task-description": "There are four blocks and four fixtures of different colors (red, blue, green, and yellow). The task involves picking up each block and inserting it into the fixture of the same color, in the specific sequence of red, blue, green, and yellow, starting from the leftmost fixture to the rightmost. The challenge lies in the precise insertion, color matching and sequence following.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "color-coordinated-block-bridge": {
+        "task-name": "color-coordinated-block-bridge",
+        "task-description": "Construct a bridge by interleaving three differently colored blocks (red, blue, and green) on a pallet in a specific sequence - red block at the edges, blue block in the middle, and a green block on top of the red and blue blocks. Repeat this sequence until a bridge is formed across the length of the pallet.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "insert-red-block-into-cylinder": {
+        "task-name": "insert-red-block-into-cylinder",
+        "task-description": "Position a red block ('insertion/ell.urdf') in front of a cylindrical fixture ('insertion/fixture.urdf'), then insert the red block into the cylinder. The challenge includes precision in positioning the block and the correct insertion into the fixture.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-sequential-ball-container-sorting": {
+        "task-name": "color-sequential-ball-container-sorting",
+        "task-description": "There are six balls of different colors (red, blue, green, yellow, orange, and purple) and six containers of matching colors. The task is to pick up each ball and place it in the container of the same color, but in a specific sequence of red, blue, green, yellow, orange, and purple from left to right. The challenge lies in the precise placement, color matching and sequence following.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-pyramid": {
+        "task-name": "color-coordinated-cylinder-pyramid",
+        "task-description": "Construct a pyramid on a pallet using four cylinders of different colors (red, blue, green, and yellow). The first level should consist of a red cylinder and a blue cylinder side by side. The second level should consist of a green cylinder placed on top of the red and blue cylinders. The third and final level should consist of a yellow cylinder placed on top of the green cylinder. The challenge lies in the precise placement of cylinders, maintaining the balance of the structure, and correct color arrangement.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "cylinder-sorting-with-zone": {
+        "task-name": "cylinder-sorting-with-zone",
+        "task-description": "On a tabletop, there are four colored cylinders (red, blue, green, and yellow) and four zones of different colors (red, blue, green, and yellow). Each cylinder is located at a zone, but not corresponding to the color of the zone. The task is to pick up each cylinder and place it in the zone of the same color, in the specific sequence of red, blue, green and yellow from left to right.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "color-coordinated-ball-placement": {
+        "task-name": "color-coordinated-ball-placement",
+        "task-description": "There are three zones marked in three different colors (red, blue, and green) and three balls of matching colors. The task involves picking up each ball and precisely placing it in the zone of the same color. However, there are a few small blocks randomly scattered in the path between the balls and the zones. The robot has to strategically navigate around these blocks without knocking them over while transporting the balls to the corresponding zones. To add to the complexity, the robot must place the balls in each zone in a specific order: red, blue, and then green from left to right. The challenge lies in the precise navigation, placement of the balls, color matching and sequence following while avoiding the blocks.",
+        "assets-used": [
+            "zone/zone.urdf",
+            "ball/ball-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "sweep-and-sort-blocks": {
+        "task-name": "sweep-and-sort-blocks",
+        "task-description": "Sweep a pile of small blocks of different colors (red, blue, green, and yellow) into their corresponding colored zones marked on the tabletop. The challenge lies in the sweeping action, precise placement, and color coordination.",
+        "assets-used": [
+            "zone/zone.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "align-cylinders-in-zones": {
+        "task-name": "align-cylinders-in-zones",
+        "task-description": "Place four differently colored cylinders (red, blue, green, yellow) each into a matching colored zone. But, the zones are surrounded by small blocks, which the robot needs to move out of the way without knocking them out of their respective zones. The challenge includes precise placement of cylinders, color matching, and careful navigation around the small blocks.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "sphere-container-color-match": {
+        "task-name": "sphere-container-color-match",
+        "task-description": "On a tabletop, there are four spheres of different colors (red, blue, green, and yellow) inside four containers of a different color (red, blue, green, and yellow). The task is to pick up each sphere and place it into a container of the same color. The task is challenging due to the manipulation of spherical objects and the color coordination required.",
+        "assets-used": [
+            "sphere/sphere.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "insertion-and-color-sorting": {
+        "task-name": "insertion-and-color-sorting",
+        "task-description": "On the tabletop, there are two fixtures and four Ell-shaped blocks of different colors (red, blue, green, and yellow). The task is to pick up each block and insert it into a fixture of the same color, then arrange the fixtures in a line in the following color order: red, blue, green, yellow. The challenge lies in the precise insertion, color matching, and sequence following.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-stack": {
+        "task-name": "color-coordinated-cylinder-stack",
+        "task-description": "On the tabletop, there are four colored (red, blue, green, yellow) cylinders and four stands of corresponding colors. The task is to pick up each cylinder and stack it onto the stand of the same color - the red one at the bottom, followed by blue, green, and finally the yellow one at the top.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-container-insertion": {
+        "task-name": "color-coordinated-container-insertion",
+        "task-description": "There are three containers and three ell shaped blocks of different colors (red, blue, green) on the table top. The task is to pick up the ell shaped blocks and insert each one of them into the container of the same color. However, the ell blocks should be inserted in a specific sequence - red first, then blue, and finally green. This task is challenging due to the precision required for insertion and the need for color coordination and sequencing.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coordinated-insertion-in-container": {
+        "task-name": "color-coordinated-insertion-in-container",
+        "task-description": "There are four differently-colored ell objects (red, blue, green, yellow) and a corresponding container of matching colors. The task involves picking up each ell object and inserting it into the container of the same color in a specific order: from left to right, insert red, blue, green, and finally yellow. The challenge lies in the precise manipulation of the ell objects and the color-coordination required.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "insert-ell-along-square-path": {
+        "task-name": "insert-ell-along-square-path",
+        "task-description": "On the tabletop, there is a square path marked by small blocks. Along the path, there are four colored ell-shaped blocks (red, blue, green, and yellow) and four fixtures of matching colors. The task is to pick up each ell block and insert it into the fixture of the same color. However, the robot must move each ell block along the marked square path to reach the fixture. The task is challenging because it requires precise navigation along the path, color coordination, and insertion accuracy.",
+        "assets-used": [
+            "block/small.urdf",
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-ordered-insertion-with-blocking-boxes": {
+        "task-name": "color-ordered-insertion-with-blocking-boxes",
+        "task-description": "There are four differently-colored ell objects (red, blue, green, yellow) and a corresponding set of color-coded fixtures. In between the ell objects and the fixtures, there are four spheres positioned randomly, creating a barrier that the robot must navigate around. The task involves picking up each ell object and inserting it into the matching color fixture in a specific order: from left to right, insert red, blue, green, and finally yellow, without knocking over any of the spheres.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "sphere/sphere-template.urdf"
+        ]
+    },
+    "color-coordinated-box-ball-matching": {
+        "task-name": "color-coordinated-box-ball-matching",
+        "task-description": "On the tabletop, there are four boxes of different colors (red, blue, green, and yellow) and four balls of corresponding colors. The task is to pick up each ball and place it inside the box of the same color, however, the boxes are placed in a straight line with a row of small blocks acting as a barrier between the boxes and the balls. The challenge lies in the precise placement, color matching, and the navigation around the barrier without knocking over any small blocks.",
+        "assets-used": [
+            "box/box-template.urdf",
+            "ball/ball-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-pallet-pyramid": {
+        "task-name": "color-coordinated-pallet-pyramid",
+        "task-description": "On a tabletop, there are three pallets and nine blocks of three different colors (red, blue, green). Each color has three blocks and the blocks are scattered randomly on the table. The task is to pick up the blocks and stack them on the pallets to form a pyramid shape. Each pyramid should contain blocks of the same color with two blocks on the base and one block on top. The pallets with the pyramids should be arranged in a straight line in the following color order: red, blue, green from left to right. The challenge lies in the color coordination, precise stacking and the arrangement of the pallets.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "color-coordinated-ball-insertion-in-boxes": {
+        "task-name": "color-coordinated-ball-insertion-in-boxes",
+        "task-description": "Pick up four balls of different colors (red, blue, green, and yellow) and insert them into four separate boxes of matching colors. The boxes are located inside corners of a square structure and the task requires precise insertion, color coordination, and careful navigation around the square structure.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "box/box-template.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "cylinder-balancing-and-placement": {
+        "task-name": "cylinder-balancing-and-placement",
+        "task-description": "On a table, there are three differently colored cylinders (red, green, and blue) and three square zones of matching colors. The task involves picking up each cylinder and balancing it on its end at the center of the corresponding colored zone, in the sequence of red, green, and blue from left to right. The task is challenging due to precise balancing required in placing the cylinders, color matching, and sequence following.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "align-spheres-in-boxes": {
+        "task-name": "align-spheres-in-boxes",
+        "task-description": "There are four different colored boxes (red, blue, green, and yellow) and four spheres of corresponding colors on the table. The task is to pick up each sphere and place it into the box of the same color. However, there are small blocks scattered randomly on the table, which the robot has to navigate without knocking them over. The challenge lies in the precise placement of the spheres, color matching, and navigation around the blocks.",
+        "assets-used": [
+            "box/box-template.urdf",
+            "sphere/sphere-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-sphere-and-cylinder-assembly": {
+        "task-name": "color-coordinated-sphere-and-cylinder-assembly",
+        "task-description": "The robot starts with four spheres of different colors (red, blue, green, yellow) and four cylinders of matching colors. The task is to pick up each sphere and place it on top of the cylinder of the same color, forming four sphere-and-cylinder pairs. However, the challenge here is to do this in a specific color sequence - red, blue, green, and finally yellow.",
+        "assets-used": [
+            "sphere/sphere-template.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-bowl-sorting": {
+        "task-name": "color-coordinated-cylinder-bowl-sorting",
+        "task-description": "There are four different cylinders (red, blue, green, yellow) and four different bowls (red, blue, green, yellow). The task involves picking up each cylinder and placing it in the bowl of the same color. The challenge lies in the precise manipulation of the cylinders and color-coordination.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "bowl/bowl.urdf"
+        ]
+    },
+    "sequential-block-insertion": {
+        "task-name": "sequential-block-insertion",
+        "task-description": "There are four blocks of different colors (red, blue, green, yellow) and four fixtures of matching colors. The task involves picking up each block and inserting it into the fixture of the same color, in the specific sequence of red, blue, green, and yellow. However, the challenge lies in the fact that the blocks and fixtures are initially arranged in a mixed order, demanding careful navigation, precise insertion, color matching, and sequence following.",
+        "assets-used": [
+            "insertion/fixture.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "sequential-insertion-and-stacking": {
+        "task-name": "sequential-insertion-and-stacking",
+        "task-description": "The tabletop contains three fixtures and three ell-shaped blocks of different colors - red, blue, and green. The task is to first pick up and insert each ell block into the corresponding colored fixture in the sequence of red, blue, and green. After successful insertion, the robot must pick up the three blocks again from the fixtures and stack them in a corner of the tabletop in the same color sequence - red at the bottom, blue in the middle, and green on top.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "color-coordinated-block-shifting": {
+        "task-name": "color-coordinated-block-shifting",
+        "task-description": "On a tabletop, there are three zones marked in three different colors (red, blue, and green) and nine blocks of matching colors (three red, three blue, and three green). Each zone initially contains three blocks of a single color, but the colors of the blocks and zones do not match. The task involves picking up each block and precisely placing it in the zone of the same color. However, there are a few small blocks randomly scattered in the path between the zones. The robot has to strategically navigate around these blocks without knocking them over while transporting the blocks to the corresponding zones. The challenge lies in the precise navigation, placement of the blocks, color matching while avoiding the blocks.",
+        "assets-used": [
+            "zone/zone.urdf",
+            "block/block.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-placement-on-pallet": {
+        "task-name": "color-coordinated-cylinder-placement-on-pallet",
+        "task-description": "On a tabletop, there are four corners marked in four different colors (red, blue, green, and yellow) and four cylinders of matching colors. Also, there is a pallet on the tabletop with four colored zones matching with the colors of the corners and cylinders. Initially, each cylinder is located at a corner, but not corresponding to the color of the corner. The task is to pick up each cylinder and place it on the pallet zone of the same color. However, this must be done in a specific sequence - red first, then blue, green, and finally yellow. The challenge lies in precise placement, color matching, and following the correct sequence.",
+        "assets-used": [
+            "corner/corner-template.urdf",
+            "cylinder/cylinder-template.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "guided-block-path": {
+        "task-name": "guided-block-path",
+        "task-description": "On the tabletop, there are four colored blocks (red, blue, green, and yellow) and four lines of the corresponding colors. The task is to pick up each block and move it along the line of the same color from start to end. The challenge lies in precise navigation along the line, color coordination, and block manipulation.",
+        "assets-used": [
+            "block/block.urdf",
+            "line/line-template.urdf"
+        ]
+    },
+    "color-ordered-insertion-with-obstacles": {
+        "task-name": "color-ordered-insertion-with-obstacles",
+        "task-description": "On a tabletop, there are four colored ell-shaped blocks (red, blue, green, and yellow) and four fixtures of matching colors, with a line of small blocks serving as barriers, and they are arranged in a straight line. The task is to pick up each ell block, navigate around the small blocks, and insert it into the fixture of the same color in a specific sequence from left to right, starting with red, followed by blue, then green, and finally yellow. The challenges include precise navigation, color coordination, sequence following, and obstacle avoidance.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-matched-block-transfer": {
+        "task-name": "color-matched-block-transfer",
+        "task-description": "On a tabletop, there are four containers and four blocks of different colors (red, blue, green, and yellow). Each block is inside a container, but not corresponding to the color of the container. The task is to pick up each block and place it in the container of the same color, in the specific sequence of red, blue, green and yellow from left to right. The task is challenging due to the precise placement, color matching and sequence following.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "mixed-color-block-barrier-insertion": {
+        "task-name": "mixed-color-block-barrier-insertion",
+        "task-description": "There are four different colored blocks (red, blue, green, and yellow), and four fixtures in corresponding colors. Two barriers, each made of three blocks (orange, purple, and brown), are placed in between the blocks and fixtures, forming a path that the robot must navigate. The task involves picking up each colored block, navigating the barriers, and inserting each block into the fixture of the same color. The fixtures are arranged in a sequence from left to right: red, blue, green, and yellow, providing a challenge in precise navigation, color coordination, and insertion.",
+        "assets-used": [
+            "block/block.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "ball-in-bowl-obstacle-course": {
+        "task-name": "ball-in-bowl-obstacle-course",
+        "task-description": "With the tabletop setup consisting of a maze of small blocks, the task requires the robot to pick up four balls of different colors (red, blue, green, yellow) and place each of them into the corresponding colored bowls strategically positioned at different corners of the maze, without knocking over any blocks, demanding careful navigation and color coordination.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "block/small.urdf",
+            "bowl/bowl.urdf"
+        ]
+    },
+    "color-coordinated-bowl-ball-pyramid": {
+        "task-name": "color-coordinated-bowl-ball-pyramid",
+        "task-description": "On a tabletop, there are four bowls and four balls of different colors (red, blue, green, and yellow). The task is to pick up each ball and stack them in the shape of a pyramid inside the bowl of the same color, in the specific sequence of red at the bottom, blue and green in the middle, and yellow at the top. The challenge lies in the precise placement, color matching, and pyramid formation.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "ball/ball.urdf"
+        ]
+    },
+    "color-coordinated-arch-construction": {
+        "task-name": "color-coordinated-arch-construction",
+        "task-description": "The task is to construct an arch using six blocks: three red and three blue. The blocks are initially placed in a container. The robot needs to pick each block and place it on a pallet in the following arrangement: place two red blocks in parallel on the pallet, then place a blue block on top of the red blocks to form an arch. Repeat the process with the remaining blocks, placing them on top of the first arch to form a second layer. The task is challenging due to the need for precise placement of the blocks and maintaining the balance of the structure.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coordinated-zone-arrangement": {
+        "task-name": "color-coordinated-zone-arrangement",
+        "task-description": "On the tabletop, there are nine blocks of three different colors (three red, three blue, and three green) and three pallets of matching colors (one red, one blue, one green). The task is to pick up each block and place it on the pallet of the same color, arranging the blocks on each pallet in a line. However, there are a few small blocks randomly scattered on the tabletop, which the robot has to navigate around without knocking them over while transporting the blocks to the corresponding pallets. The challenge lies in the precise navigation, placement of the blocks, color matching, and maintaining the balance on the pallets.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-stand-assembly": {
+        "task-name": "color-coordinated-cylinder-stand-assembly",
+        "task-description": "The robot starts with four cylinders of different colors (red, blue, green, yellow) and four stands of matching colors. The task is to pick up each cylinder and place it on top of the stand of the same color, forming four cylinder-and-stand pairs. However, the challenge here is to do this in a specific color sequence - green, yellow, blue, and finally red, while also ensuring that the cylinders do not topple over.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-stand-in-line": {
+        "task-name": "color-coordinated-cylinder-stand-in-line",
+        "task-description": "There are four stands of different colors (red, blue, green, yellow) and four cylinders of matching colors. The task is to pick up each cylinder and place it on top of the stand of the same color, forming four cylinder-and-stand pairs. However, the challenge here is to do this in a specific color sequence - red, blue, green, and finally yellow, and then line them up in a straight line from left to right according to the same color sequence.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-pyramid-construction": {
+        "task-name": "color-coordinated-pyramid-construction",
+        "task-description": "On a tabletop, there are six blocks in two colors (three red and three blue). The task involves picking up these blocks and constructing a pyramid with two levels on a stand: the first level should consist of three blocks (two red blocks and one blue block), and the second level should be formed by stacking the remaining three blocks (two blue blocks and one red block) on top of the first level. The challenge lies in the precise placement, color coordination, and maintaining the balance of the pyramid.",
+        "assets-used": [
+            "stacking/block.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-ball-stacking": {
+        "task-name": "color-coordinated-ball-stacking",
+        "task-description": "There are four balls of different colors (red, blue, green, yellow), and four containers of matching colors on the table. The task is to pick up each ball and stack it on top of the corresponding colored container. However, the stacking should be done in a specific color sequence - blue at the bottom, followed by yellow, then green, and finally red at the top. This task enforces challenging skills due to the precision required for stacking the balls, color coordination, and sequencing.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coded-blocks-on-corner": {
+        "task-name": "color-coded-blocks-on-corner",
+        "task-description": "On a tabletop, there are four blocks of different colors (red, blue, green, and yellow) and a corner structure. The task involves picking up each block and placing it in the corner structure in a specific color sequence: from left to right, place red, blue, green, and finally yellow. The blocks must be arranged such that they form a straight line along the corner. The challenge lies in the precise placement, color coordination, and maintaining the balance of the blocks along the corner.",
+        "assets-used": [
+            "block/block.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "insertion-in-color-sequenced-zones": {
+        "task-name": "insertion-in-color-sequenced-zones",
+        "task-description": "On the table, there are four differently-colored insertion ell objects (red, blue, green, yellow) and four zones on the tabletop marked in the same colors. Initially, each ell is placed in a zone but not corresponding to the color of the zone. The task is to pick up each ell and place it in the zone of the same color, in the specific sequence of red, blue, green, and yellow from left to right, requiring careful navigation, precise placement, color matching, and sequence following.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "precise-block-placement-in-container": {
+        "task-name": "precise-block-placement-in-container",
+        "task-description": "The tabletop has a row of four colored containers (red, blue, green, yellow), and twelve blocks of matching colors (three of each color). The task involves picking up each color of blocks and placing them in the container of the same color in a specific orientation: one block standing upright, one block lying flat, and one block on its side. The challenge lies in the precise placement and orientation of blocks within the confined space of the containers, while also maintaining color coordination.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coordinated-bowl-stacking": {
+        "task-name": "color-coordinated-bowl-stacking",
+        "task-description": "There are four bowls and four blocks of different colors (red, blue, green, and yellow) on the table. The task is to pick up each block and place it into the bowl of the same color. Following this, the robot must stack the bowls from largest to smallest (from bottom to top) in the sequence of red, blue, green, and yellow. The challenge lies in not only the precise placement and color coordination, but also in the delicate stacking of the bowls without toppling them over.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "color-coordinated-zone-stacking": {
+        "task-name": "color-coordinated-zone-stacking",
+        "task-description": "On the tabletop, there are three zones and nine blocks of three different colors (red, blue, green). Each color has three blocks and the blocks are scattered randomly on the table. The task is to pick up the blocks and stack them in the zones to form a pyramid shape. Each pyramid should contain blocks of the same color with two blocks on the base and one block on top. The zones with the pyramids should be arranged in a straight line in the following color order: red, blue, green from left to right. The challenge lies in the color coordination, precise stacking and the arrangement of the zones.",
+        "assets-used": [
+            "block/block.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "color-cued-ball-insertion": {
+        "task-name": "color-cued-ball-insertion",
+        "task-description": "The task area has four different colored bowls (red, blue, green, yellow) and four spheres of corresponding colors. Initially, the spheres are not in their color-matching bowls. The task is to pick up each sphere and place it in the bowl of the same color. However, the bowls are situated inside separate corners of a square structure marked by small blocks. This necessitates precise navigation around the square structure, careful picking and placing of spheres, color matching, and maintaining the balance of the bowls.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "sphere/sphere.urdf",
+            "block/small.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "color-coordinated-insertion-through-box-barrier": {
+        "task-name": "color-coordinated-insertion-through-box-barrier",
+        "task-description": "On a tabletop, there are four differently colored ell objects (red, blue, green, and yellow) and a corresponding set of color-coded fixtures. Placed in between the ell objects and the fixtures, there are two rows of boxes forming an 'L' shaped barrier. The task involves picking up each ell object and inserting it into the matching color fixture in a specific order: from left to right, insert red, blue, green, and then yellow, without knocking over any of the boxes. The challenge lies in precise navigation through the box barrier, precise insertion, color matching, and sequence following.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "box/box-template.urdf"
+        ]
+    },
+    "color-coordinated-insertion-and-stacking": {
+        "task-name": "color-coordinated-insertion-and-stacking",
+        "task-description": "On the tabletop, there are four differently colored ell-shaped objects (red, blue, green, yellow) and four fixtures of corresponding colors. The task is to pick up each ell object and insert it into the fixture of the same color. Additionally, there are four blocks of matching colors. The robot has to stack these blocks on top of the fixtures, maintaining the color coordination. However, the tabletop is marked by a square path delineated by small blocks, within which the ell objects, blocks, and fixtures are placed randomly. This necessitates precise navigation within the square path, color coordination, stacking and insertion skills.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "block/block.urdf",
+            "block/small.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-ball-match": {
+        "task-name": "color-coordinated-cylinder-ball-match",
+        "task-description": "On the tabletop, there are four cylinders of different colors (red, blue, green, and yellow) and four balls of corresponding colors. The task is to pick up each ball and place it on top of the cylinder of the same color without the ball rolling off. However, there are small blocks scattered randomly on the table that the robot has to navigate around without knocking them over. The challenge lies in the precise placement of the balls on top of the cylinders, color matching, and navigation around the blocks.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "ball/ball-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "multi-level-insertion-and-zone-matching": {
+        "task-name": "multi-level-insertion-and-zone-matching",
+        "task-description": "There are three levels of zones marked on the tabletop - the first level is red, second is blue, and third is green. On each level, there are large, medium, and small ell-shaped objects in corresponding colors. The task is to pick up each ell object from its current position and insert it into the corresponding colored zone on the same level, but in a specific order - large, medium, and small. The challenge lies in the precise control of insertion, color coordination, and the multi-level structure of the environment.",
+        "assets-used": [
+            "zone/zone.urdf",
+            "insertion/ell.urdf"
+        ]
+    },
+    "multi-color-block-sequence-insertion": {
+        "task-name": "multi-color-block-sequence-insertion",
+        "task-description": "On the tabletop, there are five blocks of different colors (red, blue, green, yellow, and orange) and five fixtures of matching colors. However, the fixtures are arranged in a mixed sequence of colors. The task involves picking up each block and inserting it into the fixture of the same color, but in a specific sequence - first red, then blue, next green, followed by yellow, and finally orange. The fixtures can be inserted only in the specified sequence and the robot cannot proceed to the next color without correctly inserting the current one. The task is challenging due to the precision required in inserting the blocks, the color coordination, and following the sequence.",
+        "assets-used": [
+            "block/block.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "ball-tower-in-zones": {
+        "task-name": "ball-tower-in-zones",
+        "task-description": "On the table, there are three spheres and three cylindrical stands of different colors (red, blue, green). The task starts with each sphere not corresponding to the stand of the same color. The task is to pick up each sphere and stack it on top of the stand of the same color while maintaining the balance. However, the stacking should be done in a specific color sequence - blue at the bottom, followed by green, and finally red at the top. The spheres and stands are each placed within separate zones, adding a challenge in precise navigation and placement.",
+        "assets-used": [
+            "sphere/sphere.urdf",
+            "zone/zone.urdf",
+            "stacking/stand.urdf"
+        ]
+    },
+    "color-coordinated-container-pyramid": {
+        "task-name": "color-coordinated-container-pyramid",
+        "task-description": "On a tabletop, there are six containers and six blocks of different colors (red, blue, green, yellow, orange, and purple). The task is to pick up each block and place it into the container of the same color, then stack these containers to form a pyramid with three levels. The first level should consist of four containers: red, blue, green, and yellow (from left to right). The second level should be constructed by placing the orange and purple containers on top of the red and blue containers respectively. The top level should be formed by placing the red container onto the orange container. The challenge lies in the precise placement, color coordination, and maintaining the balance of the pyramid.",
+        "assets-used": [
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "corner-blocks-insertion": {
+        "task-name": "corner-blocks-insertion",
+        "task-description": "On the tabletop, there are four different colored ell objects (red, blue, green, yellow) and four fixtures in the corresponding colors. Initially, each ell is placed in the corner of the table. The task is to pick up each ell and insert it into the fixture of the same color. However, there is a square-shaped barrier in the center of the table. The ell objects must be inserted in a specific sequence - red first, then blue, then green, and finally yellow. This task requires careful navigation around the barrier, precise insertion, color coordination, and sequence following.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "color-coordinated-insertion-in-cylinders": {
+        "task-name": "color-coordinated-insertion-in-cylinders",
+        "task-description": "There are four differently-colored ell objects (red, blue, green, yellow) and four cylinders of matching colors. The task involves picking up each ell object and inserting it into the cylinder of the same color in a specific order: from left to right, insert red, blue, green, and finally yellow. The challenge lies in the precise manipulation of the ell objects, the color-coordination required and the ability to correctly orient the cylinders for the insertion.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "color-coordinated-block-transport": {
+        "task-name": "color-coordinated-block-transport",
+        "task-description": "On the tabletop, there are four pallets of different colors (red, blue, green, and yellow), each containing a block of the same color. The task is to pick up each block and transport it to a container of matching color, which is located in a corner surrounded by a line of small blocks, serving as an obstacle. The robot must execute this task without disturbing the small blocks and in a specific color sequence: red first, then blue, green, and finally yellow. The task tests the robot's precise navigation, color coordination, sequence following, and obstacle avoidance capabilities.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "container/container-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-cued-ball-corner-sorting": {
+        "task-name": "color-cued-ball-corner-sorting",
+        "task-description": "On a tabletop, there are four different colored balls (red, blue, green, yellow) and four corners marked with corresponding colors using the corner template. The task involves picking up each ball and precisely placing it in the corner of the same color. However, there is a rectangular zone in the middle of the table marked by small blocks. The robot has to strategically navigate around this zone without touching the blocks while transporting the balls to the corresponding corners. The challenge lies in the precise navigation, placement of the balls, and color matching while avoiding the blocks.",
+        "assets-used": [
+            "ball/ball-template.urdf",
+            "corner/corner-template.urdf",
+            "block/block_for_anchors.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "color-coordinated-insertion-and-corner-pyramid": {
+        "task-name": "color-coordinated-insertion-and-corner-pyramid",
+        "task-description": "On a tabletop, there are four colored ell-shaped blocks (red, blue, green, and yellow) and four fixtures of corresponding colors. The task is to first pick up each ell block and insert it into the fixture of the same color in a specific sequence - red first, then blue, then green, and finally yellow. After the successful insertion, the robot must pick up the four blocks again from the fixtures and stack them in a corner-structured pyramid with red at the bottom, blue in the middle, green on the third level, and yellow on top.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "corner/corner-template.urdf"
+        ]
+    },
+    "color-coordinated-sphere-and-cylinder-stack": {
+        "task-name": "color-coordinated-sphere-and-cylinder-stack",
+        "task-description": "On the tabletop, there are four differently colored spheres (red, blue, green, and yellow) and four cylinders of the same colors. The task involves picking up each cylinder and stacking it on top of the sphere of the same color. However, the stacking should be done in a specific color sequence - blue at the bottom, followed by yellow, then green, and finally red at the top. This task enforces challenging skills due to the precision required for stacking the cylinders on top of spheres, color coordination, and sequencing.",
+        "assets-used": [
+            "sphere/sphere-template.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "color-coordinated-blocks-in-cylindrical-maze": {
+        "task-name": "color-coordinated-blocks-in-cylindrical-maze",
+        "task-description": "There are six differently colored blocks (red, blue, green, yellow, orange, and purple) and six cylindrical containers of matching colors arranged to form a maze-like structure. The task is to pick up each block and place it into the cylindrical container of the same color. The challenge lies in the precise navigation through the maze-like structure, correct color matching, and accurate placement of the blocks into the cylindrical containers.",
+        "assets-used": [
+            "block/block.urdf",
+            "cylinder/cylinder-template.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-relay": {
+        "task-name": "color-coordinated-cylinder-relay",
+        "task-description": "On the tabletop, there are four cylinders of different colors (red, blue, green, yellow) placed at one end and four zones of matching colors at the other end, with a square outline and small blocks serving as barriers between the cylinders and zones. The task is to pick up each cylinder and navigate it through the barriers to reach and place it in the zone of the same color. The task must be done in a specific sequence - red first, then blue, then green, and finally yellow. This task is challenging due to the requirement for precise navigation and placement, color coordination, and sequence following.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf",
+            "square/square-template.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-cylinder-maze": {
+        "task-name": "color-coordinated-cylinder-maze",
+        "task-description": "On the tabletop, there is a maze-like structure created by small blocks and within this maze, there are four differently colored cylinders (red, blue, green, yellow). The robot needs to pick up each cylinder and place it outside of the maze into four separate zones of matching colors. The task is challenging due to the precise navigation required within the maze, the color coordination of cylinders and zones, and the careful extraction of cylinders from the maze.",
+        "assets-used": [
+            "block/small.urdf",
+            "cylinder/cylinder-template.urdf",
+            "zone/zone.urdf"
+        ]
+    },
+    "insertion-path-obstacle-course": {
+        "task-name": "insertion-path-obstacle-course",
+        "task-description": "On the tabletop, there are four colored ell-shaped blocks (red, blue, green, and yellow) and four fixtures of matching colors. However, a line of small blocks forms a path that the robot must navigate along to insert each ell block into the fixture of the same color. The robot must move each ell block along the marked path to reach the fixture. The order for the insertion should be red, blue, green, and finally yellow from left to right. The task is challenging due to the precision required for insertion, the careful navigation along the path, and the color coordination.",
+        "assets-used": [
+            "block/small.urdf",
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf"
+        ]
+    },
+    "color-coordinated-sphere-and-bowl-match": {
+        "task-name": "color-coordinated-sphere-and-bowl-match",
+        "task-description": "On a tabletop, there are four bowls and four spheres of different sizes and colors (red, blue, green, and yellow). The task is to pick up each sphere and place it into the bowl of the same color. The challenge lies in the precision necessary for placement, the color coordination, and the size disparity between the spheres and bowls.",
+        "assets-used": [
+            "sphere/sphere-template.urdf",
+            "bowl/bowl.urdf"
+        ]
+    },
+    "color-coordinated-pallet-insertion": {
+        "task-name": "color-coordinated-pallet-insertion",
+        "task-description": "On the tabletop, there are four pallets and four ell objects of different colors (red, blue, green, yellow). Each color has one pallet and one ell object. The task is to pick up each ell object and insert it into the pallet of the same color. However, the pallets and the ell objects are initially positioned on opposite sides of a barrier formed by a line of small blocks. The robot needs to transport the ell objects over the barrier and insert them into the corresponding pallets without knocking over any blocks. The challenge lies in the precise navigation, the insertion of the ell objects into the pallets, and color matching.",
+        "assets-used": [
+            "pallet/pallet.urdf",
+            "insertion/ell.urdf",
+            "block/small.urdf"
+        ]
+    },
+    "color-coordinated-insertion-and-stack": {
+        "task-name": "color-coordinated-insertion-and-stack",
+        "task-description": "The task begins with four colored ell-shaped blocks (red, blue, green, yellow) and four fixtures of corresponding colors. The robot must pick up each ell block and insert it into the fixture of the same color in a specific sequence - red first, then blue, then green, and finally yellow. After successful insertion, the robot must pick up the four blocks again from the fixtures and stack them in a pallet to form a pyramid with red at the bottom, blue in the middle, green on the third level, and yellow on top.",
+        "assets-used": [
+            "insertion/ell.urdf",
+            "insertion/fixture.urdf",
+            "pallet/pallet.urdf"
+        ]
+    },
+    "cylinder-ring-stack": {
+        "task-name": "cylinder-ring-stack",
+        "task-description": "On the tabletop, there are four differently colored cylinders (red, blue, green, yellow) and four blocks of matching colors. The task involves picking up each block and stacking it on top of the corresponding colored cylinder. However, each cylinder and block pair should be stacked inside a differently colored container (color sequence: red cylinder and block in blue container, blue in green, green in yellow, and yellow in red). The task offers challenges in multi-object manipulation, color coordination, and precise stacking in a confined space.",
+        "assets-used": [
+            "cylinder/cylinder-template.urdf",
+            "block/block.urdf",
+            "container/container-template.urdf"
+        ]
+    },
+    "color-coordinated-sphere-on-pallet-pyramid": {
+        "task-name": "color-coordinated-sphere-on-pallet-pyramid",
+        "task-description": "On the tabletop, there are three pallets and nine blocks of three different colors (red, blue, green). Each color has three blocks and the blocks are scattered randomly on the table. The task is to pick up the blocks and stack them on the pallets to form a pyramid shape. Each pyramid should contain blocks of the same color with two blocks on the base and one block on top. Additionally, there are three spheres of matching colors (red, blue, green). The task is to pick up each sphere and place it on top of the corresponding colored pyramid. The pallets with the pyramids and spheres should be arranged in a straight line in the following color order: red, blue, green from left to right. The challenge lies in the color coordination, precise stacking, and the arrangement of the pallets.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf",
+            "sphere/sphere.urdf"
+        ]
+    },
+    "color-coordinated-stacked-block-bowls": {
+        "task-name": "color-coordinated-stacked-block-bowls",
+        "task-description": "There are three bowls and nine blocks of three different colors (red, blue, green) on the tabletop. Each color has three blocks. The task is to pick up these blocks and stack them inside the bowls in the shape of a pyramid. Each bowl should contain blocks of the same color with two blocks at the base and one block on top. The bowls with the pyramids should be arranged in a straight line in the following color order: red, blue, and green from left to right. The challenge lies in the color coordination, precise stacking, and the arrangement of the bowls.",
+        "assets-used": [
+            "bowl/bowl.urdf",
+            "block/block.urdf"
+        ]
+    },
+    "color-sequenced-sphere-placement": {
+        "task-name": "color-sequenced-sphere-placement",
+        "task-description": "On the tabletop, there are four spheres of different colors (red, blue, green, and yellow) and four colored squares of matching colors. The task involves picking up each sphere and precisely placing it in the center of the square of the same color. However, the spheres must be placed in a specific sequence - red first, then blue, then green, and finally yellow. The task is challenging due to the need for precise placement, color coordination, and sequence following.",
+        "assets-used": [
+            "sphere/sphere.urdf",
+            "square/square-template.urdf"
+        ]
+    },
+    "color-sequence-loading-pallet": {
+        "task-name": "color-sequence-loading-pallet",
+        "task-description": "On a tabletop, there are ten blocks of five different colors (two red, two blue, two green, two yellow, and two orange), and a pallet. The task is to pick up one block of each color and place them onto the pallet in a specific sequence: red, blue, green, yellow, and finally orange. Next, pick up the remaining blocks and stack them on top of the corresponding color in the same sequence. The challenge lies in the precise placement of the blocks and maintaining the load balance on the pallet.",
+        "assets-used": [
+            "block/block.urdf",
+            "pallet/pallet.urdf"
+        ]
+    }
+}

prompts/fgen.py

@@ -1,49 +0,0 @@
-import numpy as np
-from shapely.geometry import *
-from shapely.affinity import *
-
-from env_utils import get_obj_pos, get_obj_names
-from ctrl_utils import put_first_on_second
-
-# define function: total = get_total(xs=numbers).
-def get_total(xs):
-    return np.sum(xs)
-
-# define function: y = eval_line(x, slope, y_intercept=0).
-def eval_line(x, slope, y_intercept):
-    return x * slope + y_intercept
-
-# define function: pt = get_pt_to_the_left(pt, dist).
-def get_pt_to_the_left(pt, dist):
-    return pt + [-dist, 0]
-
-# define function: pt = get_pt_to_the_top(pt, dist).
-def get_pt_to_the_top(pt, dist):
-    return pt + [0, dist]
-
-# define function line = make_line_by_length(length=x).
-def make_line_by_length(length):
-  line = LineString([[0, 0], [length, 0]])
-  return line
-
-# define function: line = make_vertical_line_by_length(length=x).
-def make_vertical_line_by_length(length):
-  line = make_line_by_length(length)
-  vertical_line = rotate(line, 90)
-  return vertical_line
-
-# define function: pt = interpolate_line(line, t=0.5).
-def interpolate_line(line, t):
-  pt = line.interpolate(t, normalized=True)
-  return np.array(pt.coords[0])
-
-# example: scale a line by 2.
-line = make_line_by_length(1)
-new_shape = scale(line, xfact=2, yfact=2)
-
-# example: put object1 on top of object0.
-put_first_on_second('object1', 'object0')
-
-# example: get the position of the first object.
-obj_names = get_obj_names()
-pos_2d = get_obj_pos(obj_names[0])

prompts/parse_obj_name.py

@@ -1,59 +0,0 @@
-import numpy as np
-from env_utils import get_obj_pos, parse_position
-from utils import get_obj_positions_np
-
-objects = ['blue block', 'cyan block', 'purple bowl', 'gray bowl', 'brown bowl', 'pink block', 'purple block']
-# the block closest to the purple bowl.
-block_names = ['blue block', 'cyan block', 'purple block']
-closest_block_idx = get_closest_idx(points=get_obj_positions_np(block_names), point=get_obj_pos('purple bowl'))
-closest_block_name = block_names[closest_block_idx]
-ret_val = closest_block_name
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# the blocks.
-ret_val = ['brown block', 'blue block']
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# the brown objects.
-ret_val = ['brown bowl', 'brown block']
-objects = ['brown bowl', 'banana', 'brown block', 'apple', 'blue bowl', 'blue block']
-# a fruit that's not the apple
-fruit_names = ['banana', 'apple']
-for fruit_name in fruit_names:
-    if fruit_name != 'apple':
-        ret_val = fruit_name
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# blocks above the brown bowl.
-block_names = ['blue block', 'cyan block', 'purple block']
-brown_bowl_pos = get_obj_pos('brown bowl')
-use_block_names = []
-for block_name in block_names:
-    if get_obj_pos(block_name)[1] > brown_bowl_pos[1]:
-        use_block_names.append(block_name)
-ret_val = use_block_names
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# the blue block.
-ret_val = 'blue block'
-objects = ['blue block', 'cyan block', 'purple bowl', 'brown bowl', 'purple block']
-# the block closest to the bottom right corner.
-corner_pos = parse_position('bottom right corner')
-block_names = ['blue block', 'cyan block', 'purple block']
-closest_block_idx = get_closest_idx(points=get_obj_positions_np(block_names), point=corner_pos)
-closest_block_name = block_names[closest_block_idx]
-ret_val = closest_block_name
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# the left most block.
-block_names = ['green block', 'brown block', 'blue block']
-left_block_idx = np.argsort(get_obj_positions_np(block_names)[:, 0])[0]
-left_block_name = block_names[left_block_idx]
-ret_val = left_block_name
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# the bowl on near the top.
-bowl_names = ['brown bowl', 'green bowl', 'blue bowl']
-top_bowl_idx = np.argsort(get_obj_positions_np(bowl_names)[:, 1])[-1]
-top_bowl_name = bowl_names[top_bowl_idx]
-ret_val = top_bowl_name
-objects = ['yellow bowl', 'purple block', 'yellow block', 'purple bowl', 'pink bowl', 'pink block']
-# the third bowl from the right.
-bowl_names = ['yellow bowl', 'purple bowl', 'pink bowl']
-bowl_idx = np.argsort(get_obj_positions_np(bowl_names)[:, 0])[-3]
-bowl_name = bowl_names[bowl_idx]
-ret_val = bowl_name

prompts/parse_position.py

@@ -1,54 +0,0 @@
-import numpy as np
-from shapely.geometry import *
-from shapely.affinity import *
-from env_utils import denormalize_xy, parse_obj_name, get_obj_names, get_obj_pos
-
-# a 30cm horizontal line in the middle with 3 points.
-middle_pos = denormalize_xy([0.5, 0.5]) 
-start_pos = middle_pos + [-0.3/2, 0]
-end_pos = middle_pos + [0.3/2, 0]
-line = make_line(start=start_pos, end=end_pos)
-points = interpolate_pts_on_line(line=line, n=3)
-ret_val = points
-# a 20cm vertical line near the right with 4 points.
-middle_pos = denormalize_xy([1, 0.5]) 
-start_pos = middle_pos + [0, -0.2/2]
-end_pos = middle_pos + [0, 0.2/2]
-line = make_line(start=start_pos, end=end_pos)
-points = interpolate_pts_on_line(line=line, n=4)
-ret_val = points
-# a diagonal line from the top left to the bottom right corner with 5 points.
-top_left_corner = denormalize_xy([0, 1])
-bottom_right_corner = denormalize_xy([1, 0])
-line = make_line(start=top_left_corner, end=bottom_right_corner)
-points = interpolate_pts_on_line(line=line, n=5)
-ret_val = points
-# a triangle with size 10cm with 3 points.
-polygon = make_triangle(size=0.1, center=denormalize_xy([0.5, 0.5]))
-points = get_points_from_polygon(polygon)
-ret_val = points
-# the corner closest to the sun colored block.
-block_name = parse_obj_name('the sun colored block', f'objects = {get_obj_names()}')
-corner_positions = np.array([denormalize_xy(pos) for pos in [[0, 0], [0, 1], [1, 1], [1, 0]]])
-closest_corner_pos = get_closest_point(points=corner_positions, point=get_obj_pos(block_name))
-ret_val = closest_corner_pos
-# the side farthest from the right most bowl.
-bowl_name = parse_obj_name('the right most bowl', f'objects = {get_obj_names()}')
-side_positions = np.array([denormalize_xy(pos) for pos in [[0.5, 0], [0.5, 1], [1, 0.5], [0, 0.5]]])
-farthest_side_pos = get_farthest_point(points=side_positions, point=get_obj_pos(bowl_name))
-ret_val = farthest_side_pos
-# a point above the third block from the bottom.
-block_name = parse_obj_name('the third block from the bottom', f'objects = {get_obj_names()}')
-ret_val = get_obj_pos(block_name) + [0.1, 0]
-# a point 10cm left of the bowls.
-bowl_names = parse_obj_name('the bowls', f'objects = {get_obj_names()}')
-bowl_positions = get_all_object_positions_np(obj_names=bowl_names)
-left_obj_pos = bowl_positions[np.argmin(bowl_positions[:, 0])] + [-0.1, 0]
-ret_val = left_obj_pos
-# the bottom side.
-bottom_pos = denormalize_xy([0.5, 0])
-ret_val = bottom_pos
-# the top corners.
-top_left_pos = denormalize_xy([0, 1])
-top_right_pos = denormalize_xy([1, 1])
-ret_val = [top_left_pos, top_right_pos]

prompts/parse_question.py

@@ -1,27 +0,0 @@
-from utils import get_obj_pos, get_obj_names, parse_obj_name, bbox_contains_pt, is_obj_visible
-
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl', 'fruit', 'green block', 'black bowl']
-# is the blue block to the right of the yellow bowl?
-ret_val = get_obj_pos('blue block')[0] > get_obj_pos('yellow bowl')[0]
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl', 'fruit', 'green block', 'black bowl']
-# how many yellow objects are there?
-yellow_object_names = parse_obj_name('the yellow objects', f'objects = {get_obj_names()}')
-ret_val = len(yellow_object_names)
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# what are the blocks left of the green bowl?
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-green_bowl_pos = get_obj_pos('green bowl')
-left_block_names = []
-for block_name in block_names:
-  if get_obj_pos(block_name)[0] < green_bowl_pos[0]:
-    left_block_names.append(block_name)
-ret_val = left_block_names
-objects = ['pink block', 'yellow block', 'pink bowl', 'blue block', 'blue bowl', 'yellow bowl']
-# is the sun colored block above the blue bowl?
-sun_block_name = parse_obj_name('sun colored block', f'objects = {get_obj_names()}')
-sun_block_pos = get_obj_pos(sun_block_name)
-blue_bowl_pos = get_obj_pos('blue bowl')
-ret_val = sun_block_pos[1] > blue_bowl_pos[1]
-objects = ['pink block', 'yellow block', 'pink bowl', 'blue block', 'blue bowl', 'yellow bowl']
-# is the green block below the blue bowl?
-ret_val = get_obj_pos('green block')[1] < get_obj_pos('blue bowl')[1]

prompts/tabletop_ui.py

@@ -1,173 +0,0 @@
-# Python 2D robot control script
-import numpy as np
-from env_utils import put_first_on_second, get_obj_pos, get_obj_names, say, get_corner_name, get_side_name, is_obj_visible, stack_objects_in_order
-from plan_utils import parse_obj_name, parse_position, parse_question, transform_shape_pts
-
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# place the yellow block on the yellow bowl.
-say('Ok - putting the yellow block on the yellow bowl')
-put_first_on_second('yellow block', 'yellow bowl')
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# which block did you move.
-say('I moved the yellow block')
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# move the green block to the top right corner.
-say('Got it - putting the green block on the top right corner')
-corner_pos = parse_position('top right corner')
-put_first_on_second('green block', corner_pos)
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# stack the blue bowl on the yellow bowl on the green block.
-order_bottom_to_top = ['green block', 'yellow block', 'blue bowl']
-say(f'Sure - stacking from top to bottom: {", ".join(order_bottom_to_top)}')
-stack_objects_in_order(object_names=order_bottom_to_top)
-objects = ['cyan block', 'white block', 'cyan bowl', 'blue block', 'blue bowl', 'white bowl']
-# move the cyan block into its corresponding bowl.
-matches = {'cyan block': 'cyan bowl'}
-say('Got it - placing the cyan block on the cyan bowl')
-for first, second in matches.items():
-  put_first_on_second(first, get_obj_pos(second))
-objects = ['cyan block', 'white block', 'cyan bowl', 'blue block', 'blue bowl', 'white bowl']
-# make a line of blocks on the right side.
-say('No problem! Making a line of blocks on the right side')
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-line_pts = parse_position(f'a 30cm vertical line on the right with {len(block_names)} points')
-for block_name, pt in zip(block_names, line_pts):
-  put_first_on_second(block_name, pt)
-objects = ['yellow block', 'red block', 'yellow bowl', 'gray block', 'gray bowl', 'red bowl']
-# put the small banana colored thing in between the blue bowl and green block.
-say('Sure thing - putting the yellow block between the blue bowl and the green block')
-target_pos = parse_position('a point in the middle betweeen the blue bowl and the green block')
-put_first_on_second('yellow block', target_pos)
-objects = ['yellow block', 'red block', 'yellow bowl', 'gray block', 'gray bowl', 'red bowl']
-# can you cut the bowls in half.
-say('no, I can only move objects around')
-objects = ['yellow block', 'green block', 'yellow bowl', 'gray block', 'gray bowl', 'green bowl']
-# stack the blocks on the right side with the gray one on the bottom.
-say('Ok. stacking the blocks on the right side with the gray block on the bottom')
-right_side = parse_position('the right side')
-put_first_on_second('gray block', right_side)
-order_bottom_to_top = ['gray block', 'green block', 'yellow block']
-stack_objects_in_order(object_names=order_bottom_to_top)
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# hide the blue bowl.
-bowl_name = np.random.choice(['yellow bowl', 'green bowl'])
-say(f'Sounds good! Hiding the blue bowl under the {bowl_name}')
-put_first_on_second(bowl_name, 'blue bowl')
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# move the grass-colored bowl to the left.
-say('Sure - moving the green bowl left by 10 centimeters')
-left_pos = parse_position('a point 10cm left of the green bowl')
-put_first_on_second('green bowl', left_pos)
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# why did you move the red bowl.
-say(f'I did not move the red bowl')
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# undo that.
-say('Sure - moving the green bowl right by 10 centimeters')
-left_pos = parse_position('a point 10cm right of the green bowl')
-put_first_on_second('green bowl', left_pos)
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# place the top most block to the corner closest to the bottom most block.
-top_block_name = parse_obj_name('top most block', f'objects = {get_obj_names()}')
-bottom_block_name = parse_obj_name('bottom most block', f'objects = {get_obj_names()}')
-closest_corner_pos = parse_position(f'the corner closest to the {bottom_block_name}', f'objects = {get_obj_names()}')
-say(f'Putting the {top_block_name} on the {get_corner_name(closest_corner_pos)}')
-put_first_on_second(top_block_name, closest_corner_pos)
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# move the brown bowl to the side closest to the green block.
-closest_side_position = parse_position('the side closest to the green block')
-say(f'Got it - putting the brown bowl on the {get_side_name(closest_side_position)}')
-put_first_on_second('brown bowl', closest_side_position)
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# place the green block to the right of the bowl that has the blue block.
-bowl_name = parse_obj_name('the bowl that has the blue block', f'objects = {get_obj_names()}')
-if bowl_name:
-  target_pos = parse_position(f'a point 10cm to the right of the {bowl_name}')
-  say(f'No problem - placing the green block to the right of the {bowl_name}')
-  put_first_on_second('green block', target_pos)
-else:
-  say('There are no bowls that has the blue block')
-objects = ['brown bowl', 'green block', 'brown block', 'green bowl', 'blue bowl', 'blue block']
-# move the other blocks to the bottom corners.
-block_names = parse_obj_name('blocks other than the blue block', f'objects = {get_obj_names()}')
-corners = parse_position('the bottom corners')
-for block_name, pos in zip(block_names, corners):
-  put_first_on_second(block_name, pos)
-objects = ['pink block', 'gray block', 'orange block']
-# move the pinkish colored block on the bottom side.
-say('Ok - putting the pink block on the bottom side')
-bottom_side_pos = parse_position('the bottom side')
-put_first_on_second('pink block', bottom_side_pos)
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl']
-# is the blue block to the right of the yellow bowl?
-if parse_question('is the blue block to the right of the yellow bowl?', f'objects = {get_obj_names()}'):
-  say('yes, there is a blue block to the right of the yellow bow')
-else:
-  say('no, there is\'t a blue block to the right of the yellow bow')
-objects = ['yellow bowl', 'blue block', 'yellow block', 'blue bowl']
-# how many yellow objects are there?
-n_yellow_objs = parse_question('how many yellow objects are there', f'objects = {get_obj_names()}')
-say(f'there are {n_yellow_objs} yellow object')
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# move the left most block to the green bowl.
-left_block_name = parse_obj_name('left most block', f'objects = {get_obj_names()}')
-say(f'Moving the {left_block_name} on the green bowl')
-put_first_on_second(left_block_name, 'green bowl')
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# move the other blocks to different corners.
-block_names = parse_obj_name(f'blocks other than the {left_block_name}', f'objects = {get_obj_names()}')
-corners = parse_position('the corners')
-say(f'Ok - moving the other {len(block_names)} blocks to different corners')
-for block_name, pos in zip(block_names, corners):
-  put_first_on_second(block_name, pos)
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# is the pink block on the green bowl.
-if parse_question('is the pink block on the green bowl', f'objects = {get_obj_names()}'):
-  say('Yes - the pink block is on the green bowl.')
-else:
-  say('No - the pink block is not on the green bowl.')
-objects = ['pink block', 'green block', 'pink bowl', 'blue block', 'blue bowl', 'green bowl']
-# what are the blocks left of the green bowl.
-left_block_names =  parse_question('what are the blocks left of the green bowl', f'objects = {get_obj_names()}')
-if len(left_block_names) > 0:
-  say(f'These blocks are left of the green bowl: {", ".join(left_block_names)}')
-else:
-  say('There are no blocks left of the green bowl')
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# imagine that the bowls are different biomes on earth and imagine that the blocks are parts of a building.
-say('ok')
-objects = ['yellow block', 'green block', 'yellow bowl', 'blue block', 'blue bowl', 'green bowl']
-# now build a tower in the grasslands.
-order_bottom_to_top = ['green bowl', 'blue block', 'green block', 'yellow block']
-say('stacking the blocks on the green bowl')
-stack_objects_in_order(object_names=order_bottom_to_top)
-objects = ['yellow block', 'green block', 'yellow bowl', 'gray block', 'gray bowl', 'green bowl']
-# show me what happens when the desert gets flooded by the ocean.
-say('putting the yellow bowl on the blue bowl')
-put_first_on_second('yellow bowl', 'blue bowl')
-objects = ['pink block', 'gray block', 'orange block']
-# move all blocks 5cm toward the top.
-say('Ok - moving all blocks 5cm toward the top')
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-for block_name in block_names:
-  target_pos = parse_position(f'a point 5cm above the {block_name}')
-  put_first_on_second(block_name, target_pos)
-objects = ['cyan block', 'white block', 'purple bowl', 'blue block', 'blue bowl', 'white bowl']
-# make a triangle of blocks in the middle.
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-triangle_pts = parse_position(f'a triangle with size 10cm around the middle with {len(block_names)} points')
-say('Making a triangle of blocks around the middle of the workspace')
-for block_name, pt in zip(block_names, triangle_pts):
-  put_first_on_second(block_name, pt)
-objects = ['cyan block', 'white block', 'purple bowl', 'blue block', 'blue bowl', 'white bowl']
-# make the triangle smaller.
-triangle_pts = transform_shape_pts('scale it by 0.5x', shape_pts=triangle_pts)
-say('Making the triangle smaller')
-block_names = parse_obj_name('the blocks', f'objects = {get_obj_names()}')
-for block_name, pt in zip(block_names, triangle_pts):
-  put_first_on_second(block_name, pt)
-objects = ['brown bowl', 'red block', 'brown block', 'red bowl', 'pink bowl', 'pink block']
-# put the red block on the farthest bowl.
-farthest_bowl_name = parse_obj_name('the bowl farthest from the red block', f'objects = {get_obj_names()}')
-say(f'Putting the red block on the {farthest_bowl_name}')
-put_first_on_second('red block', farthest_bowl_name)

prompts/transform_shape_pts.py

@@ -1,19 +0,0 @@
-import numpy as np
-from utils import get_obj_pos, get_obj_names, parse_position, parse_obj_name
-
-# make it bigger by 1.5.
-new_shape_pts = scale_pts_around_centroid_np(shape_pts, scale_x=1.5, scale_y=1.5)
-# move it to the right by 10cm.
-new_shape_pts = translate_pts_np(shape_pts, delta=[0.1, 0])
-# move it to the top by 20cm.
-new_shape_pts = translate_pts_np(shape_pts, delta=[0, 0.2])
-# rotate it clockwise by 40 degrees.
-new_shape_pts = rotate_pts_around_centroid_np(shape_pts, angle=-np.deg2rad(40))
-# rotate by 30 degrees and make it slightly smaller
-new_shape_pts = rotate_pts_around_centroid_np(shape_pts, angle=np.deg2rad(30))
-new_shape_pts = scale_pts_around_centroid_np(new_shape_pts, scale_x=0.7, scale_y=0.7)
-# move it toward the blue block.
-block_name = parse_obj_name('the blue block', f'objects = {get_obj_names()}')
-block_pos = get_obj_pos(block_name)
-mean_delta = np.mean(block_pos - shape_pts, axis=1)
-new_shape_pts = translate_pts_np(shape_pts, mean_delta)

prompts/vanilla_task_generation_prompt_simple_api/cliport_prompt_api_template.txt

@@ -1,350 +0,0 @@
-Before writing the code for the task "TASK_NAME_TEMPLATE". Here are some APIs that are defined. Please confirm that you understand these APIs.
-
-"""
-class Task():
-    """Base Task class."""
-
-    def __init__(self):
-        self.ee = Suction
-        self.mode = 'train'
-        self.sixdof = False
-        self.primitive = primitives.PickPlace()
-        self.oracle_cams = cameras.Oracle.CONFIG
-
-        # Evaluation epsilons (for pose evaluation metric).
-        self.pos_eps = 0.01
-        self.rot_eps = np.deg2rad(15)
-
-        # Workspace bounds.
-        self.pix_size = 0.003125
-        self.bounds = np.array([[0.25, 0.75], [-0.5, 0.5], [0, 0.3]])
-        self.zone_bounds = np.copy(self.bounds)
-
-        self.goals = []
-        self.lang_goals = []
-        self.task_completed_desc = "task completed."
-        self.progress = 0
-        self._rewards = 0
-        self.assets_root = None
-
-    def reset(self, env):
-        if not self.assets_root:
-            raise ValueError('assets_root must be set for task, '
-                             'call set_assets_root().')
-        self.goals = []
-        self.lang_goals = []
-        self.progress = 0  # Task progression metric in range [0, 1].
-        self._rewards = 0  # Cumulative returned rewards.
-
-    # -------------------------------------------------------------------------
-    # Oracle Agent
-    # -------------------------------------------------------------------------
-
-    def oracle(self, env):
-        """Oracle agent."""
-        OracleAgent = collections.namedtuple('OracleAgent', ['act'])
-
-        def act(obs, info):
-            """Calculate action."""
-
-            # Oracle uses perfect RGB-D orthographic images and segmentation masks.
-            _, hmap, obj_mask = self.get_true_image(env)
-
-            # Unpack next goal step.
-            objs, matches, targs, replace, rotations, _, _, _ = self.goals[0]
-
-            # Match objects to targets without replacement.
-            if not replace:
-
-                # Modify a copy of the match matrix.
-                matches = matches.copy()
-
-                # Ignore already matched objects.
-                for i in range(len(objs)):
-                    object_id, (symmetry, _) = objs[i]
-                    pose = p.getBasePositionAndOrientation(object_id)
-                    targets_i = np.argwhere(matches[i, :]).reshape(-1)
-                    for j in targets_i:
-                        if self.is_match(pose, targs[j], symmetry):
-                            matches[i, :] = 0
-                            matches[:, j] = 0
-
-            # Get objects to be picked (prioritize farthest from nearest neighbor).
-            nn_dists = []
-            nn_targets = []
-            for i in range(len(objs)):
-                object_id, (symmetry, _) = objs[i]
-                xyz, _ = p.getBasePositionAndOrientation(object_id)
-                targets_i = np.argwhere(matches[i, :]).reshape(-1)
-                if len(targets_i) > 0:
-                    targets_xyz = np.float32([targs[j][0] for j in targets_i])
-                    dists = np.linalg.norm(
-                        targets_xyz - np.float32(xyz).reshape(1, 3), axis=1)
-                    nn = np.argmin(dists)
-                    nn_dists.append(dists[nn])
-                    nn_targets.append(targets_i[nn])
-
-                # Handle ignored objects.
-                else:
-                    nn_dists.append(0)
-                    nn_targets.append(-1)
-            order = np.argsort(nn_dists)[::-1]
-
-            # Filter out matched objects.
-            order = [i for i in order if nn_dists[i] > 0]
-
-            pick_mask = None
-            for pick_i in order:
-                pick_mask = np.uint8(obj_mask == objs[pick_i][0])
-
-                # Erode to avoid picking on edges.
-                # pick_mask = cv2.erode(pick_mask, np.ones((3, 3), np.uint8))
-
-                if np.sum(pick_mask) > 0:
-                    break
-
-            # Trigger task reset if no object is visible.
-            if pick_mask is None or np.sum(pick_mask) == 0:
-                self.goals = []
-                self.lang_goals = []
-                print('Object for pick is not visible. Skipping demonstration.')
-                return
-
-            # Get picking pose.
-            pick_prob = np.float32(pick_mask)
-            pick_pix = utils.sample_distribution(pick_prob)
-            # For "deterministic" demonstrations on insertion-easy, use this:
-            # pick_pix = (160,80)
-            pick_pos = utils.pix_to_xyz(pick_pix, hmap,
-                                        self.bounds, self.pix_size)
-            pick_pose = (np.asarray(pick_pos), np.asarray((0, 0, 0, 1)))
-
-            # Get placing pose.
-            targ_pose = targs[nn_targets[pick_i]]
-            obj_pose = p.getBasePositionAndOrientation(objs[pick_i][0])
-            if not self.sixdof:
-                obj_euler = utils.quatXYZW_to_eulerXYZ(obj_pose[1])
-                obj_quat = utils.eulerXYZ_to_quatXYZW((0, 0, obj_euler[2]))
-                obj_pose = (obj_pose[0], obj_quat)
-            world_to_pick = utils.invert(pick_pose)
-            obj_to_pick = utils.multiply(world_to_pick, obj_pose)
-            pick_to_obj = utils.invert(obj_to_pick)
-            place_pose = utils.multiply(targ_pose, pick_to_obj)
-
-            # Rotate end effector?
-            if not rotations:
-                place_pose = (place_pose[0], (0, 0, 0, 1))
-
-            place_pose = (np.asarray(place_pose[0]), np.asarray(place_pose[1]))
-
-            return {'pose0': pick_pose, 'pose1': place_pose}
-
-        return OracleAgent(act)
-
-    # -------------------------------------------------------------------------
-    # Reward Function and Task Completion Metrics
-    # -------------------------------------------------------------------------
-
-    def reward(self):
-        """Get delta rewards for current timestep.
-
-        Returns:
-          A tuple consisting of the scalar (delta) reward, plus `extras`
-            dict which has extra task-dependent info from the process of
-            computing rewards that gives us finer-grained details. Use
-            `extras` for further data analysis.
-        """
-        reward, info = 0, {}
-
-        # Unpack next goal step.
-        objs, matches, targs, _, _, metric, params, max_reward = self.goals[0]
-
-        # Evaluate by matching object poses.
-        if metric == 'pose':
-            step_reward = 0
-            for i in range(len(objs)):
-                object_id, (symmetry, _) = objs[i]
-                pose = p.getBasePositionAndOrientation(object_id)
-                targets_i = np.argwhere(matches[i, :]).reshape(-1)
-                for j in targets_i:
-                    target_pose = targs[j]
-                    if self.is_match(pose, target_pose, symmetry):
-                        step_reward += max_reward / len(objs)
-                        print(f"object {i} match with target {j} rew: {step_reward}")
-                        break
-
-        # Evaluate by measuring object intersection with zone.
-        elif metric == 'zone':
-            zone_pts, total_pts = 0, 0
-            obj_pts, zones = params
-            for zone_idx, (zone_pose, zone_size) in enumerate(zones):
-
-                # Count valid points in zone.
-                for obj_idx, obj_id in enumerate(obj_pts):
-                    pts = obj_pts[obj_id]
-                    obj_pose = p.getBasePositionAndOrientation(obj_id)
-                    world_to_zone = utils.invert(zone_pose)
-                    obj_to_zone = utils.multiply(world_to_zone, obj_pose)
-                    pts = np.float32(utils.apply(obj_to_zone, pts))
-                    if len(zone_size) > 1:
-                        valid_pts = np.logical_and.reduce([
-                            pts[0, :] > -zone_size[0] / 2, pts[0, :] < zone_size[0] / 2,
-                            pts[1, :] > -zone_size[1] / 2, pts[1, :] < zone_size[1] / 2,
-                            pts[2, :] < self.zone_bounds[2, 1]])
-
-                    # if zone_idx == matches[obj_idx].argmax():
-                    zone_pts += np.sum(np.float32(valid_pts))
-                    total_pts += pts.shape[1]
-            step_reward = max_reward * (zone_pts / total_pts)
-
-        # Get cumulative rewards and return delta.
-        reward = self.progress + step_reward - self._rewards
-        self._rewards = self.progress + step_reward
-
-        # Move to next goal step if current goal step is complete.
-        if np.abs(max_reward - step_reward) < 0.01:
-            self.progress += max_reward  # Update task progress.
-            self.goals.pop(0)
-            if len(self.lang_goals) > 0:
-                self.lang_goals.pop(0)
-
-        return reward, info
-
-    def done(self):
-        """Check if the task is done or has failed.
-
-        Returns:
-          True if the episode should be considered a success, which we
-            use for measuring successes, which is particularly helpful for tasks
-            where one may get successes on the very last time step, e.g., getting
-            the cloth coverage threshold on the last alllowed action.
-            However, for bag-items-easy and bag-items-hard (which use the
-            'bag-items' metric), it may be necessary to filter out demos that did
-            not attain sufficiently high reward in external code. Currently, this
-            is done in `main.py` and its ignore_this_demo() method.
-        """
-        return (len(self.goals) == 0) or (self._rewards > 0.99)
-        # return zone_done or defs_done or goal_done
-
-    # -------------------------------------------------------------------------
-    # Environment Helper Functions
-    # -------------------------------------------------------------------------
-
-    def is_match(self, pose0, pose1, symmetry):
-        """Check if pose0 and pose1 match within a threshold."""
-
-        # Get translational error.
-        diff_pos = np.float32(pose0[0][:2]) - np.float32(pose1[0][:2])
-        dist_pos = np.linalg.norm(diff_pos)
-
-        # Get rotational error around z-axis (account for symmetries).
-        diff_rot = 0
-        if symmetry > 0:
-            rot0 = np.array(utils.quatXYZW_to_eulerXYZ(pose0[1]))[2]
-            rot1 = np.array(utils.quatXYZW_to_eulerXYZ(pose1[1]))[2]
-            diff_rot = np.abs(rot0 - rot1) % symmetry
-            if diff_rot > (symmetry / 2):
-                diff_rot = symmetry - diff_rot
-
-        return (dist_pos < self.pos_eps) and (diff_rot < self.rot_eps)
-
-    def get_random_pose(self, env, obj_size):
-        """Get random collision-free object pose within workspace bounds."""
-
-        # Get erosion size of object in pixels.
-        max_size = np.sqrt(obj_size[0] ** 2 + obj_size[1] ** 2)
-        erode_size = int(np.round(max_size / self.pix_size))
-
-        _, hmap, obj_mask = self.get_true_image(env)
-
-        # Randomly sample an object pose within free-space pixels.
-        free = np.ones(obj_mask.shape, dtype=np.uint8)
-        for obj_ids in env.obj_ids.values():
-            for obj_id in obj_ids:
-                free[obj_mask == obj_id] = 0
-        free[0, :], free[:, 0], free[-1, :], free[:, -1] = 0, 0, 0, 0
-        free = cv2.erode(free, np.ones((erode_size, erode_size), np.uint8))
-
-        # if np.sum(free) == 0:
-        #     return None, None
-
-        if np.sum(free) == 0:
-            # avoid returning None, None
-            # return None, None
-            pix = (obj_mask.shape[0] // 2, obj_mask.shape[1] // 2)
-        else:
-            pix = utils.sample_distribution(np.float32(free))
-        pos = utils.pix_to_xyz(pix, hmap, self.bounds, self.pix_size)
-        pos = (pos[0], pos[1], obj_size[2] / 2)
-        theta = np.random.rand() * 2 * np.pi
-        rot = utils.eulerXYZ_to_quatXYZW((0, 0, theta))
-        return pos, rot
-
-    def get_lang_goal(self):
-        if len(self.lang_goals) == 0:
-            return self.task_completed_desc
-        else:
-            return self.lang_goals[0]
-
-    def get_reward(self):
-        return float(self._rewards)
-
-    # -------------------------------------------------------------------------
-    # Helper Functions
-    # -------------------------------------------------------------------------
-
-    def fill_template(self, template, replace):
-        """Read a file and replace key strings."""
-        full_template_path = os.path.join(self.assets_root, template)
-        with open(full_template_path, 'r') as file:
-            fdata = file.read()
-        for field in replace:
-            for i in range(len(replace[field])):
-                fdata = fdata.replace(f'{field}{i}', str(replace[field][i]))
-        alphabet = string.ascii_lowercase + string.digits
-        rname = ''.join(random.choices(alphabet, k=16))
-        tmpdir = tempfile.gettempdir()
-        template_filename = os.path.split(template)[-1]
-        fname = os.path.join(tmpdir, f'{template_filename}.{rname}')
-        with open(fname, 'w') as file:
-            file.write(fdata)
-        return fname
-
-    def get_random_size(self, min_x, max_x, min_y, max_y, min_z, max_z):
-        """Get random box size."""
-        size = np.random.rand(3)
-        size[0] = size[0] * (max_x - min_x) + min_x
-        size[1] = size[1] * (max_y - min_y) + min_y
-        size[2] = size[2] * (max_z - min_z) + min_z
-        return tuple(size)
-
-  """""
-  
-  # Environment Class
-  def add_object(self, urdf, pose, category='rigid'):
-    """List of (fixed, rigid, or deformable) objects in env."""
-    fixed_base = 1 if category == 'fixed' else 0
-    obj_id = pybullet_utils.load_urdf(
-        p,
-        os.path.join(self.assets_root, urdf),
-        pose[0],
-        pose[1],
-        useFixedBase=fixed_base)
-    self.obj_ids[category].append(obj_id)
-    return obj_id
-"""
-
-=========
-Note that the objects need to obey physics and not collide with each other, and the object goal poses need to be above the table with lower bound x=0.25, y=-0.5 and upper bound x=0.75, y=0.5. When there are multiple objects for a multi-step pick-and-place task, there are often multiple subgoals. Once the task and environment are generated, an agent with a pick and place primitive will follow the defined goal to accomplish the tasks. 
-
-Additionally, make sure you understand and summarize the ``self.goals`` variables, which has a list of 8-tuple with (objs, matches, targ_poses, replace, rotations, metric, params, step_max_reward, symmetries).
-- objs (List of obj_id): object ID.
-- matches (Binary Matrix): a binary matrix that denotes which object is matched with which target. This matrix has dimension len(objs) x len(targs).
-- targ_poses (List of Poses [(translation, rotation)] ): a list of target poses of tuple (translation, rotation). Don't pass in object IDs such as `bowls[i-1][0]` or  `[stands[i][0]]`. 
-- replace (Boolean): whether each object can match with one unique target.   This is important if we have one target and multiple objects. If it's set to be false, then any object matching with the target will satisfy.
-- rotations (Boolean): whether the placement action has a rotation degree of freedom. 
-- metric (`pose` or `zone`): `pose` or `zone` that the object needs to be transported to. Example: `pose`. 
-- params (List of (zone_target, zone_size)): a list of (zone_target, zone_size) for each zone if the metric is `zone`. 
-- step_max_reward (float): subgoal reward threshold.  
-- symmetries: the radians that the object is symmetric around z axis.
- 

prompts/vanilla_task_generation_prompt_simple_api/cliport_prompt_code_split_template.txt

@@ -1,252 +0,0 @@
-Now I will provide you some reference code and you can write the code for the task "TASK_NAME_TEMPLATE".
-
-
-"""
-import os
-
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-
-class PackingShapes(Task):
-    """pick up randomly sized shapes and place them tightly into a container."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 1
-        self.homogeneous = False
-
-        self.lang_template = "pack the {obj} in the brown box"
-        self.task_completed_desc = "done packing shapes."
-        self.additional_reset()
-
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Shape Names:
-        shapes = utils.assembling_kit_shapes
-
-        n_objects = 5
-        if self.mode == 'train':
-            obj_shapes = np.random.choice(self.train_set, n_objects, replace=False)
-        else:
-            if self.homogeneous:
-                obj_shapes = [np.random.choice(self.test_set, replace=False)] * n_objects
-            else:
-                obj_shapes = np.random.choice(self.test_set, n_objects, replace=False)
-
-        # Shuffle colors to avoid always picking an object of the same color
-        colors, color_names = utils.get_colors(mode=self.mode)
-
-        # Add container box.
-        zone_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-        zone_pose = self.get_random_pose(env, zone_size)
-        container_template = 'container/container-template.urdf'
-        replace = {'DIM': zone_size, 'HALF': (zone_size[0] / 2, zone_size[1] / 2, zone_size[2] / 2)}
-        # IMPORTANT: REPLACE THE TEMPLATE URDF with `fill_template`
-        container_urdf = self.fill_template(container_template, replace)
-        env.add_object(container_urdf, zone_pose, 'fixed')
-
-        # Add objects.
-        objects = []
-        template = 'kitting/object-template.urdf'
-        for i in range(n_objects):
-            shape = obj_shapes[i]
-
-            # x, y, z dimensions for the asset size
-            size = (0.08, 0.08, 0.02)
-            pose= self.get_random_pose(env, size)
-            fname = f'{shape:02d}.obj'
-            fname = os.path.join(self.assets_root, 'kitting', fname)
-            scale = [0.003, 0.003, 0.001]  
-            replace = {'FNAME': (fname,),
-                       'SCALE': scale,
-                       'COLOR': colors[i]}
-
-            # IMPORTANT: REPLACE THE TEMPLATE URDF
-            urdf = self.fill_template(template, replace)
-            block_id = env.add_object(urdf, pose)
-            objects.append(block_id)
-
-        # Pick the first shape.
-        num_objects_to_pick = 1
-        for i in range(num_objects_to_pick):
-            # IMPORTANT: Specify (obj_pts, [(zone_pose, zone_size)]) for target `zone`. obj_pts is a dict
-            self.add_goal(objs=[objects[i]], matches=np.int32([[1]]), targ_poses=[zone_pose], replace=False,
-                rotations=True, metric='zone', params=[(zone_pose, zone_size)], step_max_reward=1 / num_objects_to_pick)
-
-            self.lang_goals.append(self.lang_template.format(obj=shapes[obj_shapes[i]]))
-"""
-"""
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-
-class PlaceRedInGreen(Task):
-    """pick up the red blocks and place them into the green bowls amidst other objects."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 10
-        self.lang_template = "put the red blocks in a green bowl"
-        self.task_completed_desc = "done placing blocks in bowls."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-        n_bowls = np.random.randint(1, 4)
-        n_blocks = np.random.randint(1, n_bowls + 1)
-
-        # Add bowls.
-        # x, y, z dimensions for the asset size
-        bowl_size = (0.12, 0.12, 0)
-        bowl_urdf = 'bowl/bowl.urdf'
-        bowl_poses = []
-        for _ in range(n_bowls):
-            bowl_pose = self.get_random_pose(env, obj_size=bowl_size)
-            env.add_object(urdf=bowl_urdf, pose=bowl_pose, category='fixed')
-            bowl_poses.append(bowl_pose)
-
-        # Add blocks.
-        # x, y, z dimensions for the asset size
-        blocks = []
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'stacking/block.urdf'
-        for _ in range(n_blocks):
-            block_pose = self.get_random_pose(env, obj_size=block_size)
-            block_id = env.add_object(block_urdf, block_pose)
-            blocks.append(block_id)
-
-        # Goal: each red block is in a different green bowl.
-        self.add_goal(objs=blocks, matches=np.ones((len(blocks), len(bowl_poses))), targ_poses=bowl_poses, replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1)
-        self.lang_goals.append(self.lang_template)
-
-        # Colors of distractor objects.
-        # IMPORTANT: RETRIEVE THE ACTUAL COLOR VALUES
-        bowl_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'green']
-        block_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'red']
-
-        # Add distractors.
-        n_distractors = 0
-        while n_distractors < 6:
-            is_block = np.random.rand() > 0.5
-            urdf = block_urdf if is_block else bowl_urdf
-            size = block_size if is_block else bowl_size
-            colors = block_colors if is_block else bowl_colors
-            pose = self.get_random_pose(env, obj_size=size)
-            color = colors[n_distractors % len(colors)]
-
-            obj_id = env.add_object(urdf, pose, color=color)
-            n_distractors += 1
-"""
-"""
-import numpy as np
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-
-class SweepingPiles(Task):
-    """Push piles of small objects into a target goal zone marked on the tabletop."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "push the pile of blocks into the green square"
-        self.task_completed_desc = "done sweeping."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add goal zone.
-        zone_size = (0.12, 0.12, 0)
-        zone_pose = self.get_random_pose(env, zone_size)
-        env.add_object('zone/zone.urdf', zone_pose, 'fixed')
-
-        #  use `make_piles` to add pile of small blocks.
-        obj_ids = self.make_piles(env)
-
-        # Add goal
-        self.add_goal(objs=obj_ids, matches=np.ones((50, 1)), targ_poses=[zone_pose], replace=True,
-                rotations=False, metric='zone', params=[(zone_pose, zone_size)], step_max_reward=1)
-        self.lang_goals.append(self.lang_template)
-"""
-"""
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-class StackBlockPyramid(Task):
-    """Build a pyramid of colored blocks in a color sequence"""
-
-    def __init__(self):If you have only one goal, `step_max_reward` in `add_goal` should be 1.
-        super().__init__()
-        self.max_steps = 12
-        self.lang_template = "make the {row} row with {blocks}"
-        self.task_completed_desc = "done stacking block pyramid."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add base.
-        base_size = (0.05, 0.15, 0.005)
-        base_urdf = 'stacking/stand.urdf'
-        base_pose = self.get_random_pose(env, base_size)
-        env.add_object(base_urdf, base_pose, category='fixed')
-
-        # Block colors.
-        colors = [
-            utils.COLORS['purple'], utils.COLORS['blue'], utils.COLORS['green'],
-            utils.COLORS['yellow'], utils.COLORS['orange'], utils.COLORS['red']
-        ]
-
-        # Add blocks.
-        # x, y, z dimensions for the asset size
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'stacking/block.urdf'
-
-        objs = []
-        for i in range(6):
-            block_pose = self.get_random_pose(env, block_size)
-            block_id = env.add_object(block_urdf, block_pose, color=colors[i])
-            objs.append(block_id)
-
-        # Associate placement locations for goals.
-        place_pos = [(0, -0.05, 0.03), (0, 0, 0.03),
-                     (0, 0.05, 0.03), (0, -0.025, 0.08),
-                     (0, 0.025, 0.08), (0, 0, 0.13)]
-        targs = [(utils.apply(base_pose, i), base_pose[1]) for i in place_pos]
-
-        # Goal: blocks are stacked in a pyramid (bottom row: green, blue, purple).
-        self.add_goal(objs=objs[:3], matches=np.ones((3, 3)), targ_poses=targs[:3], replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1 / 2, symmetries=[np.pi/2]*3)
-        self.lang_goals.append(self.lang_template.format(blocks="the green, blue and purple blocks",
-                                                         row="bottom"))
-
-        # Goal: blocks are stacked in a pyramid (middle row: yellow, orange).
-        self.add_goal(objs=objs[3:5], matches=np.ones((3, 3)), targ_poses=targs[3:5], replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1 / 3, symmetries=[np.pi/2]*3)
-        self.lang_goals.append(self.lang_template.format(blocks="the yellow and orange blocks",
-                                                         row="middle"))
-
-        # Goal: blocks are stacked in a pyramid (top row: red).
-        self.add_goal(objs=objs[5:], matches=np.ones((3, 3)), targ_poses=targs[5:], replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1 / 6, symmetries=[np.pi/2]*3)
-        self.lang_goals.append(self.lang_template.format(blocks="the red block",
-                                                         row="top"))
-"""
-
-
-
-Do not use libraries, functions, and assets that you don't know. For each object, try to describe its color, size, category in the task first before you write the code. You do not need extra helper functions. Comment the code liberally to explain what each piece does and why it's written that way. If you have only one goal, `step_max_reward` in `add_goal` should be 1. Use functions `make_piles` and `make_cables` for creating piles and cables. To use spatula together with the push primitives, import the libraries and then use `self.primitive = primitives.push` and `self.ee = Spatula`.
-
-Now write the code for the task "TASK_NAME_TEMPLATE" in python code block starting with ```python.  Reminder: TASK_STRING_TEMPLATE 

prompts/vanilla_task_generation_prompt_simple_api/cliport_prompt_task.txt

@@ -1,154 +0,0 @@
-You are an AI in robot simulation code and task design. I will provide you some example tasks, code implementation, and some guidelines for how to generate tasks and then you will help me generate a new task. My goal is to design diverse and feasible tasks for tabletop manipulation. I will first ask you to describe the task in natural languages and then will let you write the code for it. 
-
-=========
-Here are all the assets. Use only these assets in the task and code design. 
-"""
-insertion/:
-ell.urdf  fixture.urdf
-
-bowl/:
-bowl.urdf
-
-box/:
-box-template.urdf
-
-stacking/:
-block.urdf  stand.urdf
-
-zone/:
-zone.obj  zone.urdf
-
-pallet/:
-pallet.obj  pallet.urdf
-
-ball/:
-ball-template.urdf
-
-cylinder/:
-cylinder-template.urdf
-
-bowl/:
-bowl.urdf
-
-# assets not for picking
-corner/:
-corner-template.urdf
-
-line/:
-single-green-line-template.urdf
-
-container/:
-container-template.urdf
-"""
- 
-=========
-Here are some examples of good tasks. Try to learn from these structures but avoid overlapping wiht them.
-
-{"assets-used": ["zone/zone.urdf", "block/small.urdf"],
- "task-description": "Push piles of small objects into a target goal zone marked on the tabletop.",
- "task-name": "sweeping-piles"}
-
-{"assets-used": ["bowl/bowl.urdf", "stacking/block.urdf"],
- "task-description": "Place all blocks of a specified color in a bowl of specified color.",
- "task-name": "put-block-in-bowl"}
- 
-{"assets-used": ["insertion/ell.urdf", "insertion/fixture.urdf"],
- "task-description": "pick up the L-shaped red block and place it into the L-shaped fixture.",
- "task-name": "block-insertion"}
- 
-{"assets-used": ["kitting/kit.urdf", "kitting/object-template.urdf"],
- "task-description": "pick up different objects and arrange them on a board marked with corresponding silhouettes.",
- "task-name": "assembling-kits"}
- 
-{"assets-used": ["pallet/pallet.urdf", "box/box-template.urdf"],
- "task-description": "pick up homogeneous fixed-sized boxes and stack them in transposed layers on the pallet.",
- "task-name": "palletizing-boxes"}
- 
-{"assets-used": ["stacking/stand.urdf", "stacking/block.urdf"],
- "task-description": "sequentially stack 6 blocks into a pyramid of 3-2-1 with rainbow colored ordering.",
- "task-name": "stack-block-pyramid"}
- 
-{"assets-used": ["container/container-template.urdf", "box/box-template.urdf"],
- "task-description": "pick up randomly sized boxes and place them tightly into a container.",
- "task-name": "packing-boxes"}
- 
-{"assets-used": ["bowl/bowl.urdf", "stacking/block.urdf"],
- "task-description": "pick up the red blocks and place them into the green bowls amidst other objects.",
- "task-name": "place-red-in-green"}
- 
-{"assets-used": ["box/box-template.urdf", "corner/corner-template.urdf"],
- "task-description": "pick up the randomly sized box and align one of its corners to the L-shaped marker on the tabletop..",
- "task-name": "align-box-corner"}
-
-{"assets-used": ["box/box-template.urdf", "corner/corner-template.urdf"],
- "task-description": "pick up the randomly sized box and align one of its corners to the L-shaped marker on the tabletop..",
- "task-name": "align-box-corner"}
-
-=========
-Here are some tasks that you have come up with before. Try to learn from these structures but avoid overlapping with these tasks. For instance, `bowl_ball_placement` and `sort_balls_in_bowls` are the same task. `pile_boxes_in_corner` and `stack_blocks_into_pallet` are similar tasks, `align-cylinder-in-corner` and `align-cylinder-corner` are similar.
-PAST_TASKNAME_TEMPLATE
-
-
-=========
-Here are some bad example task instances with explanations.
-{
-    "task_name": "sort-color-blocks",
-    "task_descriptions": "Pick up differently colored blocks and place them into separate bowls of matching color."
-    "assets-used": ["bowl.urdf", "box/box-template.urdf],
-}
-reasons: not interesting because it overlaps with the current task `put-block-in-bowl`.
-
-{
-    "task-name": "guided-ball-maze",
-    "task-description": "Navigate a small ball through a maze by tilting the maze board to reach the target zone.",
-    "assets-used": ["zone-template.urdf", "square-template.urdf", "ball.urdf", "maze.urdf"],
-}
-reasons: the language descriptions are too ambiguous. Navigation is also hard to complete. Also maze.urf does not exist.
-
-{
-    "task-name": "insert_cylinder_in_sphere",
-    "task-description": "Pick up the cylinder and insert it into the sphere with an opening on top.",
-    "assets-used": ["cylinder/cylinder-template.urdf", "sphere/sphere-template.urdf"],
-}
-reasons: this task does not make sense. The sphere does not have an opening on top, and you cannot insert a cylinder into a sphere. Similarly tasks like `insert-ball-into-cylinder` and `cylinder-box-insertion` are invalid.
-
-{
-    "task-name": "ball-box-obstacle-course",
-    "task-description": "Navigate a ball through an obstacle course created by randomly placed boxes and finally place it inside a container.",
-    "assets-used": ["ball/ball-template.urdf", "box/box-template.urdf", "container/container-template.urdf"]
-}
-reasons: Navigate the ball is not related to tabletop manipulation tasks.
-
-{
-    "task-name": "ball-in-box",
-    "task-description": "Use a cable to guide a ball into an open box.",
-    "assets-used": ["cable/cable.urdf", "ball/ball-template.urdf", "box/box-template.urdf"]
-}
-reasons: This task is too hard since it involves interaction of the cable and the ball and cannot be easily completed.
-
-{
-    "task-name": "ball-in-container",
-    "task-description": "Use the spatula to lift a ball over a wall of boxes and drop it into a container.",
-    "assets-used": ["ball/ball-template.urdf", "box/box-template.urdf", "container/container-template.urdf"]
-}
-reasons: The only action primitives as pick and place. One cannot use a spatula to lift an object.
-
-{
-    "task-name": "line-ball-sorting",
-    "task-description": "Move balls of different colors along a single green line, placing each ball in a designated colored box at the end of the line. The challenge includes precision in maintaining the ball on the line and the correct identification of the box color corresponding to each ball.",
-    "assets-used": ["ball/ball-template.urdf", "box/box-template.urdf", "line/single-green-line-template.urdf"]
-}
-reasons: Piling or stacking balls are physically infeasible in the simulation.
-
-
-
-=========
-Now please describe the new task in natural languages and explain its novelty and challenges. Format the answer in a python dictionary with keys "task-name" and value type string, "task-description" (one specific sentence) and value type string, and "assets-used" and value type list of strings. Note that
-
-- Do not use assets that are not in the list above. 
-- Tasks that have more colors and shapes are interesting.
-- Be as specific as possible about the number, shape, and color of each asset in the task descriptions. 
-- The task need to obey physics and remain feasible.
-
-
-

prompts/vanilla_task_generation_prompt_simple_codeonly/cliport_prompt_code_split_template.txt

@@ -1 +0,0 @@
-Repeat the answer python code that you give in the previous chats.

prompts/vanilla_task_generation_prompt_simple_codeonly/cliport_prompt_task.txt

@@ -1,195 +0,0 @@
-You are an AI in robot simulation code and task design. I will provide you some example tasks, code implementation, and some guidelines for how to generate tasks and then you will help me generate a new task. My goal is to design diverse and feasible tasks for tabletop manipulation. I will first ask you to describe the task in natural languages and then will let you write the code for it. 
-
-=========
-Here are all the assets. Use only these assets in the task and code design. 
-"""
-insertion/:
-ell.urdf  fixture.urdf
-
-bowl/:
-bowl.urdf
-
-box/:
-box-template.urdf
-
-stacking/:
-block.urdf  stand.urdf
-
-zone/:
-zone.obj  zone.urdf
-
-pallet/:
-pallet.obj  pallet.urdf
-
-ball/:
-ball-template.urdf
-
-cylinder/:
-cylinder-template.urdf
-
-bowl/:
-bowl.urdf
-
-# assets not for picking
-corner/:
-corner-template.urdf
-
-line/:
-single-green-line-template.urdf
-
-container/:
-container-template.urdf
-"""
-
-
-=========
-Now I will provide you some reference code and you can write the code for the task.
-
-
-"""
-import os
-
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-
-class PackingShapes(Task):
-    """pick up randomly sized shapes and place them tightly into a container."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 1
-        self.homogeneous = False
-
-        self.lang_template = "pack the {obj} in the brown box"
-        self.task_completed_desc = "done packing shapes."
-        self.additional_reset()
-
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Shape Names:
-        shapes = utils.assembling_kit_shapes
-
-        n_objects = 5
-        if self.mode == 'train':
-            obj_shapes = np.random.choice(self.train_set, n_objects, replace=False)
-        else:
-            if self.homogeneous:
-                obj_shapes = [np.random.choice(self.test_set, replace=False)] * n_objects
-            else:
-                obj_shapes = np.random.choice(self.test_set, n_objects, replace=False)
-
-        # Shuffle colors to avoid always picking an object of the same color
-        colors, color_names = utils.get_colors(mode=self.mode)
-
-        # Add container box.
-        zone_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-        zone_pose = self.get_random_pose(env, zone_size)
-        container_template = 'container/container-template.urdf'
-        replace = {'DIM': zone_size, 'HALF': (zone_size[0] / 2, zone_size[1] / 2, zone_size[2] / 2)}
-        # IMPORTANT: REPLACE THE TEMPLATE URDF with `fill_template`
-        container_urdf = self.fill_template(container_template, replace)
-        env.add_object(container_urdf, zone_pose, 'fixed')
-
-        # Add objects.
-        objects = []
-        template = 'kitting/object-template.urdf'
-        for i in range(n_objects):
-            shape = obj_shapes[i]
-
-            # x, y, z dimensions for the asset size
-            size = (0.08, 0.08, 0.02)
-            pose= self.get_random_pose(env, size)
-            fname = f'{shape:02d}.obj'
-            fname = os.path.join(self.assets_root, 'kitting', fname)
-            scale = [0.003, 0.003, 0.001]  
-            replace = {'FNAME': (fname,),
-                       'SCALE': scale,
-                       'COLOR': colors[i]}
-
-            # IMPORTANT: REPLACE THE TEMPLATE URDF
-            urdf = self.fill_template(template, replace)
-            block_id = env.add_object(urdf, pose)
-            objects.append(block_id)
-
-        # Pick the first shape.
-        num_objects_to_pick = 1
-        for i in range(num_objects_to_pick):
-            # IMPORTANT: Specify (obj_pts, [(zone_pose, zone_size)]) for target `zone`. obj_pts is a dict
-            self.add_goal(objs=[objects[i]], matches=np.int32([[1]]), targ_poses=[zone_pose], replace=False,
-                rotations=True, metric='zone', params=[(zone_pose, zone_size)], step_max_reward=1 / num_objects_to_pick)
-
-            self.lang_goals.append(self.lang_template.format(obj=shapes[obj_shapes[i]]))
-"""
-"""
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-
-class PlaceRedInGreen(Task):
-    """pick up the red blocks and place them into the green bowls amidst other objects."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 10
-        self.lang_template = "put the red blocks in a green bowl"
-        self.task_completed_desc = "done placing blocks in bowls."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-        n_bowls = np.random.randint(1, 4)
-        n_blocks = np.random.randint(1, n_bowls + 1)
-
-        # Add bowls.
-        # x, y, z dimensions for the asset size
-        bowl_size = (0.12, 0.12, 0)
-        bowl_urdf = 'bowl/bowl.urdf'
-        bowl_poses = []
-        for _ in range(n_bowls):
-            bowl_pose = self.get_random_pose(env, obj_size=bowl_size)
-            env.add_object(urdf=bowl_urdf, pose=bowl_pose, category='fixed')
-            bowl_poses.append(bowl_pose)
-
-        # Add blocks.
-        # x, y, z dimensions for the asset size
-        blocks = []
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'stacking/block.urdf'
-        for _ in range(n_blocks):
-            block_pose = self.get_random_pose(env, obj_size=block_size)
-            block_id = env.add_object(block_urdf, block_pose)
-            blocks.append(block_id)
-
-        # Goal: each red block is in a different green bowl.
-        self.add_goal(objs=blocks, matches=np.ones((len(blocks), len(bowl_poses))), targ_poses=bowl_poses, replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1)
-        self.lang_goals.append(self.lang_template)
-
-        # Colors of distractor objects.
-        # IMPORTANT: RETRIEVE THE ACTUAL COLOR VALUES
-        bowl_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'green']
-        block_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'red']
-
-        # Add distractors.
-        n_distractors = 0
-        while n_distractors < 6:
-            is_block = np.random.rand() > 0.5
-            urdf = block_urdf if is_block else bowl_urdf
-            size = block_size if is_block else bowl_size
-            colors = block_colors if is_block else bowl_colors
-            pose = self.get_random_pose(env, obj_size=size)
-            color = colors[n_distractors % len(colors)]
-
-            obj_id = env.add_object(urdf, pose, color=color)
-            n_distractors += 1
-"""
-
-=========
-Now write the code for the task "TASK_NAME_TEMPLATE" in python code block starting with ```python.  
-

prompts/vanilla_task_generation_prompt_simple_singleprompt/cliport_prompt_code_split_template.txt

@@ -1 +0,0 @@
-Repeat the answer python code that you give in the previous chats.

prompts/vanilla_task_generation_prompt_simple_singleprompt/cliport_prompt_task.txt

@@ -1,202 +0,0 @@
-You are an AI in robot simulation code and task design. I will provide you some example tasks, code implementation, and some guidelines for how to generate tasks and then you will help me generate a new task. My goal is to design diverse and feasible tasks for tabletop manipulation. I will first ask you to describe the task in natural languages and then will let you write the code for it. 
-
-=========
-Here are all the assets. Use only these assets in the task and code design. 
-"""
-insertion/:
-ell.urdf  fixture.urdf
-
-bowl/:
-bowl.urdf
-
-box/:
-box-template.urdf
-
-stacking/:
-block.urdf  stand.urdf
-
-zone/:
-zone.obj  zone.urdf
-
-pallet/:
-pallet.obj  pallet.urdf
-
-ball/:
-ball-template.urdf
-
-cylinder/:
-cylinder-template.urdf
-
-bowl/:
-bowl.urdf
-
-# assets not for picking
-corner/:
-corner-template.urdf
-
-line/:
-single-green-line-template.urdf
-
-container/:
-container-template.urdf
-"""
-
-
-=========
-Now I will provide you some reference code and you can write the code for the task.
-
-
-"""
-import os
-
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-
-class PackingShapes(Task):
-    """pick up randomly sized shapes and place them tightly into a container."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 1
-        self.homogeneous = False
-
-        self.lang_template = "pack the {obj} in the brown box"
-        self.task_completed_desc = "done packing shapes."
-        self.additional_reset()
-
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Shape Names:
-        shapes = utils.assembling_kit_shapes
-
-        n_objects = 5
-        if self.mode == 'train':
-            obj_shapes = np.random.choice(self.train_set, n_objects, replace=False)
-        else:
-            if self.homogeneous:
-                obj_shapes = [np.random.choice(self.test_set, replace=False)] * n_objects
-            else:
-                obj_shapes = np.random.choice(self.test_set, n_objects, replace=False)
-
-        # Shuffle colors to avoid always picking an object of the same color
-        colors, color_names = utils.get_colors(mode=self.mode)
-
-        # Add container box.
-        zone_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-        zone_pose = self.get_random_pose(env, zone_size)
-        container_template = 'container/container-template.urdf'
-        replace = {'DIM': zone_size, 'HALF': (zone_size[0] / 2, zone_size[1] / 2, zone_size[2] / 2)}
-        # IMPORTANT: REPLACE THE TEMPLATE URDF with `fill_template`
-        container_urdf = self.fill_template(container_template, replace)
-        env.add_object(container_urdf, zone_pose, 'fixed')
-
-        # Add objects.
-        objects = []
-        template = 'kitting/object-template.urdf'
-        for i in range(n_objects):
-            shape = obj_shapes[i]
-
-            # x, y, z dimensions for the asset size
-            size = (0.08, 0.08, 0.02)
-            pose= self.get_random_pose(env, size)
-            fname = f'{shape:02d}.obj'
-            fname = os.path.join(self.assets_root, 'kitting', fname)
-            scale = [0.003, 0.003, 0.001]  
-            replace = {'FNAME': (fname,),
-                       'SCALE': scale,
-                       'COLOR': colors[i]}
-
-            # IMPORTANT: REPLACE THE TEMPLATE URDF
-            urdf = self.fill_template(template, replace)
-            block_id = env.add_object(urdf, pose)
-            objects.append(block_id)
-
-        # Pick the first shape.
-        num_objects_to_pick = 1
-        for i in range(num_objects_to_pick):
-            # IMPORTANT: Specify (obj_pts, [(zone_pose, zone_size)]) for target `zone`. obj_pts is a dict
-            self.add_goal(objs=[objects[i]], matches=np.int32([[1]]), targ_poses=[zone_pose], replace=False,
-                rotations=True, metric='zone', params=[(zone_pose, zone_size)], step_max_reward=1 / num_objects_to_pick)
-
-            self.lang_goals.append(self.lang_template.format(obj=shapes[obj_shapes[i]]))
-"""
-"""
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import pybullet as p
-
-
-class PlaceRedInGreen(Task):
-    """pick up the red blocks and place them into the green bowls amidst other objects."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 10
-        self.lang_template = "put the red blocks in a green bowl"
-        self.task_completed_desc = "done placing blocks in bowls."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-        n_bowls = np.random.randint(1, 4)
-        n_blocks = np.random.randint(1, n_bowls + 1)
-
-        # Add bowls.
-        # x, y, z dimensions for the asset size
-        bowl_size = (0.12, 0.12, 0)
-        bowl_urdf = 'bowl/bowl.urdf'
-        bowl_poses = []
-        for _ in range(n_bowls):
-            bowl_pose = self.get_random_pose(env, obj_size=bowl_size)
-            env.add_object(urdf=bowl_urdf, pose=bowl_pose, category='fixed')
-            bowl_poses.append(bowl_pose)
-
-        # Add blocks.
-        # x, y, z dimensions for the asset size
-        blocks = []
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'stacking/block.urdf'
-        for _ in range(n_blocks):
-            block_pose = self.get_random_pose(env, obj_size=block_size)
-            block_id = env.add_object(block_urdf, block_pose)
-            blocks.append(block_id)
-
-        # Goal: each red block is in a different green bowl.
-        self.add_goal(objs=blocks, matches=np.ones((len(blocks), len(bowl_poses))), targ_poses=bowl_poses, replace=False,
-                rotations=True, metric='pose', params=None, step_max_reward=1)
-        self.lang_goals.append(self.lang_template)
-
-        # Colors of distractor objects.
-        # IMPORTANT: RETRIEVE THE ACTUAL COLOR VALUES
-        bowl_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'green']
-        block_colors = [utils.COLORS[c] for c in utils.COLORS if c != 'red']
-
-        # Add distractors.
-        n_distractors = 0
-        while n_distractors < 6:
-            is_block = np.random.rand() > 0.5
-            urdf = block_urdf if is_block else bowl_urdf
-            size = block_size if is_block else bowl_size
-            colors = block_colors if is_block else bowl_colors
-            pose = self.get_random_pose(env, obj_size=size)
-            color = colors[n_distractors % len(colors)]
-
-            obj_id = env.add_object(urdf, pose, color=color)
-            n_distractors += 1
-"""
-=========
-Now please describe the new task in natural languages and explain its novelty and challenges. Format the answer in a python dictionary with keys "task-name" and value type string, "task-description" (one specific sentence) and value type string, and "assets-used" and value type list of strings. Note that
-
-- Do not use assets that are not in the list above. 
-- Tasks that have more colors and shapes are interesting.
-- Be as specific as possible about the number, shape, and color of each asset in the task descriptions. 
-- The task need to obey physics and remain feasible.
-
-=========
-Now write the code for the task "TASK_NAME_TEMPLATE" in python code block starting with ```python.  
-