narrow exception in count_input_cfg_levels to FileNotFoundError

The broad  silently swallowed all errors when
_resolve_if_path could not load a YAML file, masking real problems
(permission errors, malformed YAML, etc.).

The only legitimate failure case is FileNotFoundError: when a nested
input_cfg YAML contains OmegaConf interpolations like
, raw yaml.load returns them as
literal strings that don't exist on disk.  parse_and_combine_datasets
resolves these later via OmegaConf.create().  All other errors should
propagate immediately since they would also crash parse_and_combine_datasets.

Also documents file-path input_cfg depth counting in the RST docs.

Signed-off-by: Xuesong Yang <1646669+XuesongYang@users.noreply.github.com>

Author: XuesongYang

docs/source/audio/configs.rst

@@ -221,6 +221,28 @@ The maximum nesting depth is calculated as the maximum depth of ``input_cfg`` ke
         input_cfg:                      # Level 2 (same as above)
           - type: lhotse_shar
 
+When ``input_cfg`` is overridden via CLI to a YAML file path (e.g.
+``model.train_ds.input_cfg=train_all.yaml``), the depth calculation loads the
+referenced file and traverses its contents to count nested ``input_cfg`` keys.
+This also works with multi-level file references:
+
+.. code-block:: yaml
+
+    # train_all.yaml (referenced via input_cfg=train_all.yaml)
+    - type: group
+      weight: 100
+      input_cfg: ${oc.env:MANIFEST_ROOT}/train_en.yaml   # resolved at runtime
+    - type: group
+      weight: 200
+      input_cfg: ${oc.env:MANIFEST_ROOT}/train_de.yaml
+
+.. note::
+
+    Paths containing OmegaConf interpolations (e.g. ``${oc.env:MANIFEST_ROOT}``)
+    cannot be resolved during depth counting -- they are resolved later at runtime
+    by ``OmegaConf.create()``. Such paths are treated as a single additional
+    nesting level.
+
 **Example: Balancing Multiple Task Groups**
 
 .. code-block:: yaml

nemo/collections/common/data/lhotse/cutset.py

@@ -478,9 +478,10 @@ def count_input_cfg_levels(config: Union[DictConfig, dict]) -> int:
 
     String/Path values for ``input_cfg`` are treated as file references (mirroring
     :func:`parse_and_combine_datasets`) and loaded so that nested ``input_cfg``
-    keys inside those files are counted.  If a file cannot be loaded (e.g. the
-    path contains unresolved OmegaConf interpolations), it is conservatively
-    counted as one additional level.
+    keys inside those files are counted.  If the file is not found (e.g. the
+    path contains unresolved OmegaConf interpolations such as
+    ``${oc.env:MANIFEST_ROOT}``), it is conservatively counted as one additional
+    level.  All other I/O or parsing errors propagate immediately.
 
     Args:
         config: Configuration dictionary that may contain nested 'input_cfg' keys.
@@ -502,13 +503,20 @@ def count_input_cfg_levels(config: Union[DictConfig, dict]) -> int:
     _cache: dict[str, object] = {}
 
     def _resolve_if_path(val):
-        """If *val* is a string/Path, try to load the YAML it points to."""
+        """If *val* is a string/Path, load the YAML file it points to.
+
+        Raises on I/O or parse errors except ``FileNotFoundError``, which is
+        expected when the path contains OmegaConf interpolations (e.g.
+        ``${oc.env:MANIFEST_ROOT}/file.yaml``) that raw ``yaml.load`` returns
+        as literal strings.  ``parse_and_combine_datasets`` resolves them at
+        runtime via ``OmegaConf.create()``.
+        """
         if isinstance(val, (str, Path)):
             key = str(val)
             if key not in _cache:
                 try:
                     _cache[key] = load_yaml(key)
-                except Exception:
+                except FileNotFoundError:
                     logging.debug("count_input_cfg_levels: could not load %r, treating as leaf", key)
                     _cache[key] = val
             return _cache[key]