Name the declared checkpoints for what they are

"Auxiliary" ranked these files below the policy and did not generalise:
any component can declare a run artifact, and the policy is not special
among them. The discovery and path helpers, their parameter, and the
collect locals now say declared.

Author: hujc7

scripts/tools/train_and_publish_checkpoints.py

@@ -83,8 +83,8 @@
 from isaaclab_rl.utils.pretrained_checkpoint import (
     WORKFLOW_EXPERIMENT_NAME_VARIABLE,
     WORKFLOWS,
-    get_auxiliary_checkpoint_path,
-    get_auxiliary_checkpoints,
+    get_declared_checkpoint_path,
+    get_declared_checkpoints,
     get_latest_job_run_path,
     get_pretrained_checkpoint_backend_names,
     get_pretrained_checkpoint_filename,
@@ -119,7 +119,7 @@ class CheckpointJob:
     render_selector: str | None = None
     agent: str | None = None
     algorithm: str | None = None
-    auxiliary_checkpoints: tuple[Checkpoint, ...] = ()
+    declared_checkpoints: tuple[Checkpoint, ...] = ()
     """Run artifacts the task publishes beside its policy."""
 
     @property
@@ -365,7 +365,7 @@ def _build_core_jobs(args: argparse.Namespace) -> list[CheckpointJob]:
                         render_selector=render_selector,
                         agent=agent,
                         algorithm=algorithm,
-                        auxiliary_checkpoints=tuple(get_auxiliary_checkpoints(env_cfg)),
+                        declared_checkpoints=tuple(get_declared_checkpoints(env_cfg)),
                     )
                 )
     return jobs
@@ -547,14 +547,14 @@ def collect_pretrained_checkpoint(job: CheckpointJob, output_dir: str, dry_run:
     os.makedirs(os.path.dirname(destination), exist_ok=True)
     shutil.copy2(source_path, destination)
     run_path = get_latest_job_run_path(job.workflow, job.task_name, job.physics_backend, job.render_backend)
-    for checkpoint in job.auxiliary_checkpoints:
-        aux_source = checkpoint.find_in(run_path)
-        if aux_source is None:
+    for checkpoint in job.declared_checkpoints:
+        declared_source = checkpoint.find_in(run_path)
+        if declared_source is None:
             print(f"No {checkpoint.name} checkpoint matched {checkpoint.run_glob!r} for {job.job_id}")
             continue
-        aux_destination = get_auxiliary_checkpoint_path(destination, job.workflow, checkpoint)
-        print(f"Collecting {aux_source} -> {aux_destination}")
-        shutil.copy2(aux_source, aux_destination)
+        declared_destination = get_declared_checkpoint_path(destination, job.workflow, checkpoint)
+        print(f"Collecting {declared_source} -> {declared_destination}")
+        shutil.copy2(declared_source, declared_destination)
     return destination
 
 
@@ -659,12 +659,12 @@ def publish_pretrained_checkpoint(job: CheckpointJob, args: argparse.Namespace)
         )
         publish_path = posixpath.join(args.publish_root.rstrip("/"), job.workflow, filename)
     uploads = [(local_path, publish_path)]
-    for checkpoint in job.auxiliary_checkpoints:
-        local_auxiliary = get_auxiliary_checkpoint_path(local_path, job.workflow, checkpoint)
-        if not os.path.isfile(local_auxiliary):
+    for checkpoint in job.declared_checkpoints:
+        local_declared = get_declared_checkpoint_path(local_path, job.workflow, checkpoint)
+        if not os.path.isfile(local_declared):
             print(f"Skipping the {checkpoint.name} checkpoint for {job.job_id}; it was not collected")
             continue
-        uploads.append((local_auxiliary, get_auxiliary_checkpoint_path(publish_path, job.workflow, checkpoint)))
+        uploads.append((local_declared, get_declared_checkpoint_path(publish_path, job.workflow, checkpoint)))
     for source, destination in uploads:
         print(f"Publishing {source} -> {destination}")
     if args.dry_run:

source/isaaclab_rl/isaaclab_rl/utils/pretrained_checkpoint.py

@@ -221,7 +221,7 @@ def get_published_pretrained_checkpoint_path(
     return posixpath.join(*path_parts, filename)
 
 
-def get_auxiliary_checkpoints(
+def get_declared_checkpoints(
     env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg,
 ) -> list[Checkpoint]:
     """Return the run artifacts a task publishes beside its policy checkpoint.
@@ -245,8 +245,8 @@ def get_auxiliary_checkpoints(
     return list(unique.values())
 
 
-def get_auxiliary_checkpoint_path(checkpoint_path: str, workflow: str, checkpoint: Checkpoint) -> str:
-    """Return where an auxiliary checkpoint lives beside a policy checkpoint path.
+def get_declared_checkpoint_path(checkpoint_path: str, workflow: str, checkpoint: Checkpoint) -> str:
+    """Return where a declared checkpoint lives beside a policy checkpoint path.
 
     Args:
         checkpoint_path: Local or published path of the policy checkpoint.
@@ -292,11 +292,11 @@ def get_published_pretrained_checkpoint(
     Returns:
         The path.
     """
-    auxiliary_checkpoints: Sequence[Checkpoint] = ()
+    declared_checkpoints: Sequence[Checkpoint] = ()
     if env_cfg is not None:
         if physics_backend is None and render_backend is None:
             physics_backend, render_backend = get_pretrained_checkpoint_backend_names(env_cfg)
-        auxiliary_checkpoints = get_auxiliary_checkpoints(env_cfg)
+        declared_checkpoints = get_declared_checkpoints(env_cfg)
     ov_path = get_published_pretrained_checkpoint_path(workflow, task_name, physics_backend, render_backend)
     # one cache directory per published checkpoint: play treats it as the run log directory and
     # writes videos, exported policies, and additional checkpoints into it
@@ -310,8 +310,8 @@ def get_published_pretrained_checkpoint(
     if resume_path is None:
         print("A pre-trained checkpoint is currently unavailable for this task.")
         return None
-    for checkpoint in auxiliary_checkpoints:
-        _fetch(get_auxiliary_checkpoint_path(ov_path, workflow, checkpoint), download_dir)
+    for checkpoint in declared_checkpoints:
+        _fetch(get_declared_checkpoint_path(ov_path, workflow, checkpoint), download_dir)
     return resume_path
 
 

source/isaaclab_rl/test/test_pretrained_checkpoint.py

@@ -257,19 +257,19 @@ def test_get_published_pretrained_checkpoint_tolerates_no_feature_extractor(
         ),
     ],
 )
-def test_get_auxiliary_checkpoint_path_keeps_the_declared_extension(checkpoint, expected):
-    """Test that a published auxiliary keeps the extension the component declared."""
-    path = pretrained_checkpoint.get_auxiliary_checkpoint_path(
+def test_get_declared_checkpoint_path_keeps_the_declared_extension(checkpoint, expected):
+    """Test that a published checkpoint keeps the extension the component declared."""
+    path = pretrained_checkpoint.get_declared_checkpoint_path(
         "/logs/Isaac-Cartpole_physx_none_rsl_rl.pt", "rsl_rl", checkpoint
     )
     assert path == expected
 
 
-def test_get_auxiliary_checkpoints_discovers_nested_component_configs():
+def test_get_declared_checkpoints_discovers_nested_component_configs():
     """Test that a component config declaring a checkpoint is found without the task listing it."""
-    assert pretrained_checkpoint.get_auxiliary_checkpoints(_EnvCfg()) == []
+    assert pretrained_checkpoint.get_declared_checkpoints(_EnvCfg()) == []
 
-    found = pretrained_checkpoint.get_auxiliary_checkpoints(_EnvCfg(extractor=_ExtractorCfg()))
+    found = pretrained_checkpoint.get_declared_checkpoints(_EnvCfg(extractor=_ExtractorCfg()))
 
     # only run artifacts are published beside the policy; URL weights are the component's to fetch
     assert [(c.name, c.run_glob) for c in found] == [("feature_extractor", "cnn_*.pth")]

source/isaaclab_tasks/test/core/test_shadow_hand_camera_presets.py

@@ -32,7 +32,7 @@
 from isaaclab.renderers import RendererCfg
 from isaaclab.sensors import CameraCfg
 
-from isaaclab_rl.utils.pretrained_checkpoint import get_auxiliary_checkpoints
+from isaaclab_rl.utils.pretrained_checkpoint import get_declared_checkpoints
 
 from isaaclab_tasks.core.reorient.config.shadow_hand.feature_extractor import FeatureExtractor, FeatureExtractorCfg
 from isaaclab_tasks.core.reorient.config.shadow_hand.shadow_hand_camera_manager_env_cfg import (
@@ -307,5 +307,5 @@ def test_camera_task_publishes_the_feature_extractor_checkpoint():
     expected = FeatureExtractorCfg().checkpoint
 
     for env_cfg in (ShadowHandCameraEnvCfg(), ShadowHandCameraManagerEnvCfg()):
-        (found,) = get_auxiliary_checkpoints(env_cfg)
+        (found,) = get_declared_checkpoints(env_cfg)
         assert (found.name, found.run_glob) == (expected.name, expected.run_glob)