Local validation plus some refactoring

Signed-off-by: Mike Knepper <mknepper@nvidia.com>

Author: mikeknep

packages/data_designer_nemo/src/data_designer_nemo/context.py

@@ -23,7 +23,10 @@
 )
 from data_designer_nemo.errors import NDDError
 from data_designer_nemo.fileset_file_seed_reader import FilesetFileSeedReader
-from data_designer_nemo.fileset_filesystem_provider import FilesetFileSystemProvider, HybridFileSystemProvider
+from data_designer_nemo.fileset_filesystem_provider import (
+    FilesetFileSystemProvider,
+    HybridFileSystemProvider,
+)
 from data_designer_nemo.model_provider import (
     make_local_first_model_provider_registry,
     make_model_provider_registry,
@@ -34,10 +37,7 @@
 from data_designer_nemo.sdk_translation import sync_to_async_sdk
 from data_designer_nemo.secret_resolver import NMPSecretResolver
 from data_designer_nemo.seed import validate_seed
-from data_designer_nemo.unsupported_features import (
-    validate_no_tool_configs,
-    validate_seed_config_for_execution_context,
-)
+from data_designer_nemo.tool_configs import validate_no_tool_configs
 from nemo_platform import AsyncNeMoPlatform, NeMoPlatform
 
 
@@ -65,6 +65,7 @@ class LocalDataDesignerContext:
     def __init__(self, sdk: AsyncNeMoPlatform | NeMoPlatform, workspace: str):
         self._sdk = sdk
         self._workspace = workspace
+        self._validated_filesystem_roots: set[str] = set()
 
     def get_secret_resolver(self) -> SecretResolver:
         return CompositeResolver(
@@ -76,19 +77,25 @@ def get_secret_resolver(self) -> SecretResolver:
         )
 
     async def validate(self, config: dd.DataDesignerConfig) -> list[NDDError]:
+        sdk = self._async_sdk()
         errors: list[NDDError] = []
+
         try:
-            validate_seed_config_for_execution_context(config, is_local=True)
+            if validated_root := await validate_seed(config, self._workspace, sdk, is_local=True):
+                self._validated_filesystem_roots.add(validated_root)
         except NDDError as e:
             errors.append(e)
+
         return errors
 
     def get_seed_readers(self) -> list[SeedReader]:
         # Directory- and FileContents-style seeds may reference either a local
         # directory or a NeMo Platform fileset in local mode. The engine only
         # accepts one provider per reader, so we inject a hybrid provider that
         # resolves each seed path against local disk first, then a fileset.
-        fs_provider = HybridFileSystemProvider(self._sdk, workspace=self._workspace)
+        fs_provider = HybridFileSystemProvider(
+            self._sdk, workspace=self._workspace, validated_roots=self._validated_filesystem_roots
+        )
         return [
             HuggingFaceSeedReader(),
             LocalFileSeedReader(),
@@ -114,6 +121,11 @@ async def get_model_providers(self, model_configs: list[dd.ModelConfig]) -> list
 
         return [make_noop_provider()]
 
+    def _async_sdk(self) -> AsyncNeMoPlatform:
+        if isinstance(self._sdk, NeMoPlatform):
+            return sync_to_async_sdk(self._sdk)
+        return self._sdk
+
 
 class RemoteDataDesignerContext:
     def __init__(self, sdk: AsyncNeMoPlatform | NeMoPlatform, workspace: str):
@@ -132,15 +144,13 @@ async def validate(self, config: dd.DataDesignerConfig) -> list[NDDError]:
             validate_no_tool_configs(config)
         except NDDError as e:
             errors.append(e)
+
         try:
-            validate_seed_config_for_execution_context(config, is_local=False)
-        except NDDError as e:
-            errors.append(e)
-        try:
-            if validated_root := await validate_seed(config, self._workspace, sdk):
+            if validated_root := await validate_seed(config, self._workspace, sdk, is_local=False):
                 self._validated_filesystem_roots.add(validated_root)
         except NDDError as e:
             errors.append(e)
+
         try:
             await ensure_nemotron_personas_filesets(config, sdk)
         except NDDError as e:

packages/data_designer_nemo/src/data_designer_nemo/fileset_filesystem_provider.py

@@ -30,7 +30,7 @@ class _FilesetDirFileSystem(DirFileSystem):
     this remains a complete AbstractFileSystem implementation.
     """
 
-    def _relpath(self, path: str | list) -> str | list:  # type: ignore[override]
+    def _relpath(self, path: str | list) -> str | list:
         if isinstance(path, list):
             return [self._relpath(p) for p in path]
         if not self.path:
@@ -122,10 +122,16 @@ def ensure_root_exists(self, *, runtime_path: str) -> None:
         self._route(runtime_path).ensure_root_exists(runtime_path=runtime_path)
 
     def _route(self, runtime_path: str) -> FileSystemProvider:
-        return self._local if _is_local_directory(runtime_path) else self._fileset
+        return self._local if is_local_directory(runtime_path) else self._fileset
 
 
-def _is_local_directory(runtime_path: str) -> bool:
+def is_local_directory(runtime_path: str) -> bool:
+    """Whether a seed path resolves to an existing directory on the local filesystem.
+
+    Shared by ``HybridFileSystemProvider`` routing and local-mode seed validation so
+    that eager validation and read-time routing always agree on which backend serves
+    a given path.
+    """
     try:
         return Path(runtime_path).expanduser().is_dir()
     except (OSError, ValueError, RuntimeError):

packages/data_designer_nemo/src/data_designer_nemo/seed.py

@@ -2,30 +2,58 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+from typing import Any
 
 import data_designer.config as dd
 from data_designer.config.seed_source import SeedSource
 from data_designer_nemo.errors import NDDInternalError, NDDInvalidConfigError
 from data_designer_nemo.fileset_file_seed_source import FilesetFileSeedSource
+from data_designer_nemo.fileset_filesystem_provider import is_local_directory
 from data_designer_nemo.secret_resolver import validate_secret
 from nemo_platform import AsyncNeMoPlatform, NotFoundError, PermissionDeniedError
 from nemo_platform.filesets import FilesetPathError, build_fileset_ref, parse_fileset_ref
 
 logger = logging.getLogger(__name__)
 
-
-def get_seed_source(dd_config: dd.DataDesignerConfig) -> SeedSource | None:
-    return dd_config.seed_config.source if dd_config.seed_config else None
+_SUPPORTED_SEED_TYPES = {"directory", "file_contents", "hf", "nmp"}
+_UNSUPPORTED_SEED_TYPES_MESSAGE = (
+    "The NeMo Platform Data Designer service only supports seed data from HuggingFace "
+    "or the NeMo Platform Files service (FilesetFile, Directory, or FileContents seed sources "
+    "referencing fileset paths). Upload your data to the Files service, adjust your config, and try again."
+)
+_DATAFRAME_SEED_TYPE = "df"
+_DATAFRAME_SEED_TYPE_MESSAGE = (
+    "Dataframe seed sources (seed_type=df) are not supported on the NeMo Platform. TODO: more detail here!"
+)
 
 
-async def validate_seed(dd_config: dd.DataDesignerConfig, workspace: str, sdk: AsyncNeMoPlatform) -> str | None:
-    if (seed_source := get_seed_source(dd_config)) is None:
+async def validate_seed(
+    dd_config: dd.DataDesignerConfig,
+    workspace: str,
+    sdk: AsyncNeMoPlatform,
+    is_local: bool,
+) -> str | None:
+    if (seed_source := _get_seed_source(dd_config)) is None:
         return None
 
-    if isinstance(seed_source, dd.HuggingFaceSeedSource) and (token := seed_source.token) is not None:
-        await validate_secret(sdk, token, workspace)
+    _validate_seed_type_for_execution_context(
+        seed_source.seed_type,
+        is_local=is_local,
+    )
+
+    if isinstance(seed_source, dd.HuggingFaceSeedSource):
+        # In local execution context, a HF seed source token will always "resolve"
+        # because the composite secret resolver includes a plaintext resolver.
+        # In remote execution context, a HF seed source token must be a reference
+        # to a Nemo Platform secret (if provided).
+        if not is_local and (token := seed_source.token) is not None:
+            await validate_secret(sdk, token, workspace)
         return None
 
+    if is_local and isinstance(seed_source, dd.DirectorySeedSource | dd.FileContentsSeedSource):
+        if is_local_directory(seed_source.path):
+            return None
+
     if isinstance(seed_source, FilesetFileSeedSource | dd.DirectorySeedSource | dd.FileContentsSeedSource):
         return await _validate_seed_from_files_service(seed_source, workspace, sdk)
 
@@ -78,3 +106,63 @@ async def _validate_seed_from_files_service(
         raise NDDInvalidConfigError(f"Path {fragment!r} not found in fileset {fully_qualified_fileset_name!r}")
 
     return canonical_root
+
+
+def validate_seed_source_for_execution_context(data: Any, *, is_local: bool) -> None:
+    """Raises if a raw request seed source is unsupported for the execution context.
+
+    This function is used in Pydantic validators defined on the preview and job request models,
+    both of which carry a `config: dd.DataDesignerConfig` field.
+
+    This function is used in "before"-style Pydantic validators, where the data argument is typed
+    as Any. We run in the before context to preempt less-useful error messages from the DD library:
+    - missing dataframe field (we don't serialize dataframes over the wire)
+    - file does not exist (the client's local fs != the service's local fs)
+
+    The validators using this function only care about preventing unsupported seed types. All the
+    other standard Pydantic validation will get applied by FastAPI parsing the request; this does
+    not bypass that. So, we can safely ignore all Exceptions (most commonly KeyError, on requests
+    that don't include a seed_config at all) and index our way straight to the deeply nested field
+    we care about for this particular validation.
+
+    Per the Pydantic v2 contract, "before"-mode validators may raise ``ValueError``,
+    ``AssertionError``, or ``PydanticCustomError`` — anything else (including our
+    ``NDDInvalidConfigError``) propagates raw out of ``model_validate`` and is not wrapped in
+    ``pydantic.ValidationError``. That breaks ``except ValidationError`` clauses in CLI / framework
+    code that turn validation problems into clean user-facing messages. To keep those code paths
+    working *and* keep ``NDDInvalidConfigError`` as the canonical error class for non-Pydantic
+    callers, we translate at this boundary: catch the plugin's error class and re-raise as a
+    ``ValueError`` carrying the same message.
+    """
+    seed_type = _get_raw_seed_type(data)
+    if seed_type is None:
+        return
+
+    try:
+        _validate_seed_type_for_execution_context(seed_type, is_local=is_local)
+    except NDDInvalidConfigError as exc:
+        raise ValueError(str(exc)) from exc
+
+
+def _validate_seed_type_for_execution_context(seed_type: str, *, is_local: bool) -> None:
+    """Raises if a seed source type is unsupported in this execution context."""
+    if is_local:
+        if seed_type == _DATAFRAME_SEED_TYPE:
+            raise NDDInvalidConfigError(_DATAFRAME_SEED_TYPE_MESSAGE)
+        return
+
+    if seed_type not in _SUPPORTED_SEED_TYPES:
+        raise NDDInvalidConfigError(_UNSUPPORTED_SEED_TYPES_MESSAGE)
+
+
+def _get_seed_source(dd_config: dd.DataDesignerConfig) -> SeedSource | None:
+    return dd_config.seed_config.source if dd_config.seed_config else None
+
+
+def _get_raw_seed_type(data: Any) -> str | None:
+    try:
+        seed_type = data["config"]["seed_config"]["source"]["seed_type"]
+    except Exception:
+        return None
+
+    return seed_type if isinstance(seed_type, str) else None

packages/data_designer_nemo/src/data_designer_nemo/tool_configs.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import data_designer.config as dd
+from data_designer_nemo.errors import NDDInvalidConfigError
+
+
+def validate_no_tool_configs(config: dd.DataDesignerConfig) -> None:
+    if config.tool_configs and len(config.tool_configs) > 0:
+        raise NDDInvalidConfigError("Tool configs are not supported in the NeMo Platform Data Designer service.")