robolab/core/task/task.py

# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0

from dataclasses import dataclass
from typing import Any

from isaaclab.managers import TerminationTermCfg as TerminationCfg
from isaaclab.scene import InteractiveSceneCfg


@dataclass
class Task:
    """Base task configuration with scene, terminations, and instruction.

    instruction can be a plain string or a dict mapping type keys to strings, e.g.:
        instruction: str = "Pick up the banana"
        instruction = {"default": "Pick up the banana", "vague": "Move it", "specific": "..."}
    When a dict is used, omit the type annotation so Python treats it as a class
    variable (avoids mutable-default dataclass errors).
    """

    # These will be set by subclasses
    scene: InteractiveSceneCfg | Any = None
    instruction: str | dict[str, str] = ""
    terminations: TerminationCfg | Any = None
    rewards: Any = None  # Optional reward terms for RL training
    events: Any = None  # Optional event terms (e.g., randomization)
    subtasks: Any = None  # Subtasks for completion tracking
    contact_object_list: list[str] | None = None  # list of objects that can be in contact with the robot and will be tracked for contact sensors

    episode_length_s: int = 60*10 # 10 minutes
    attributes: list[str] = None
    task_name: str = None  # Optional: explicit task name (defaults to class name). Useful for grouping task variants.


def resolve_instruction(instruction: str | dict[str, str], instruction_type: str = "default") -> str:
    """Resolve an instruction field to a plain string.

    If instruction is already a str, return it unchanged (instruction_type is ignored).
    If instruction is a dict, look up instruction_type, falling back to "default".
    """
    if isinstance(instruction, str):
        return instruction
    if instruction_type in instruction:
        return instruction[instruction_type]
    if "default" in instruction:
        return instruction["default"]
    raise ValueError(
        f"Instruction type '{instruction_type}' not found. Available: {list(instruction.keys())}"
    )


def verify_task_valid(task_class: type[Task]) -> tuple[bool, str]:
    """
    Verify if a task file is valid.
    """
    if task_class is None:
        error = f"Task class {task_class.__name__} is None."
        return False, error

    if task_class.terminations is None:
        error = f"Task class {task_class.__name__} has no terminations."
        return False, error

    if task_class.contact_object_list is None:
        error = f"Task class {task_class.__name__} has no contact object list: {task_class.contact_object_list}"
        return False, error

    if task_class.episode_length_s <= 0:
        error = f"Task class {task_class.__name__} episode length is not set or is less than 0: {task_class.episode_length_s}"
        return False, error

    # Check if contact_object_list matches scene objects
    contact_list_valid, error = verify_contact_objects_in_scene(task_class)
    if not contact_list_valid:
        error = f"Contact list is not valid: {error}"
        return False, error

    # Check terminations
    terminations = task_class.terminations()
    termination_success_func = getattr(terminations, 'success', None)
    if termination_success_func is not None:
        func = termination_success_func.func
        params = termination_success_func.params
        from robolab.core.utils.function_loader import verify_callable_args_supplied
        valid, error = verify_callable_args_supplied(func, params)
        if not valid:
            error = task_class.__name__ + " is not a valid task class. " + error
            return False, error

        for obj_args in ["object", "container", "objects", "reference_object", "surface"]:
            if obj_args in params:
                objects = params.get(obj_args, [])
                if isinstance(objects, str):
                    objects = [objects]
                elif isinstance(objects, list):
                    pass
                else:
                    error = f"Object argument used in termination '{obj_args}' is not a string or list: {objects}"
                    return False, error
                for obj in objects:
                    if obj not in task_class.contact_object_list:
                        error = f"Object used in termination '{obj}' under argument '{obj_args}' is not in contact object list: {task_class.contact_object_list}"
                        return False, error

    return True, None


def verify_contact_objects_in_scene(task_class: type[Task]) -> tuple[bool, str]:
    """
    Verify that all objects in the task's contact_object_list are present in the scene.

    Args:
        task_class: The task class to verify

    Returns:
        tuple[bool, list[str]]: (is_valid, list_of_error_messages)
    """


    # Try to extract the scene USD path
    try:
        scene = getattr(task_class, 'scene', None)
        if scene is None:
            error = "Task has no scene attribute"
            return False, error

        # Get the scene USD path by traversing scene.scene.spawn.usd_path
        usd_path = getattr(getattr(getattr(scene, 'scene', None), 'spawn', None), 'usd_path', None)

        # If no USD path found, check if scene has individual object attributes
        if usd_path is None:
            # Get all attributes from the scene class (not instance methods)
            # Use __annotations__ if available, otherwise check class __dict__
            if hasattr(scene, '__annotations__'):
                scene_attributes = list(scene.__annotations__.keys())
            else:
                scene_attributes = [attr for attr in vars(scene) if not attr.startswith('_') and attr != 'scene']

            # Check if all contact objects are present as scene attributes
            missing_objects = [obj for obj in task_class.contact_object_list if obj not in scene_attributes]

            if missing_objects:
                error = f"Contact objects not found in scene attributes: {missing_objects}. Scene has: {scene_attributes}"
                return False, error

            # All objects found in scene attributes
            return True, None

    except Exception as e:
        error = f"Error extracting scene path: {e}"
        return False, error

    from robolab.core.scenes.utils import verify_objects_in_scene
    # Verify that the contact objects are in the scene USD file
    contact_list_valid, error = verify_objects_in_scene(task_class.contact_object_list, usd_path)
    if not contact_list_valid:
        return False, error

    return True, None