data-designer 0.1.0__py3-none-any.whl

data_designer/cli/forms/field.py

@@ -0,0 +1,180 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+from data_designer.cli.utils import validate_numeric_range
+
+T = TypeVar("T")
+
+
+class ValidationError(Exception):
+    """Field validation error."""
+
+
+class Field(ABC, Generic[T]):
+    """Base class for form fields."""
+
+    def __init__(
+        self,
+        name: str,
+        prompt: str,
+        default: T | None = None,
+        required: bool = True,
+        validator: Callable[[str], tuple[bool, str | None]] | None = None,
+        help_text: str | None = None,
+    ):
+        self.name = name
+        self.prompt = prompt
+        self.default = default
+        self.required = required
+        self.validator = validator
+        self.help_text = help_text
+        self._value: T | None = None
+
+    @property
+    def value(self) -> T | None:
+        """Get the current field value."""
+        return self._value
+
+    @value.setter
+    def value(self, val: T) -> None:
+        """Set and validate the field value."""
+        if self.validator:
+            # For string validators, convert to string first if needed
+            val_str = str(val) if not isinstance(val, str) else val
+            is_valid, error_msg = self.validator(val_str)
+            if not is_valid:
+                raise ValidationError(error_msg or "Invalid value")
+        self._value = val
+
+    @abstractmethod
+    def prompt_user(self, allow_back: bool = False) -> T | None | Any:
+        """Prompt user for input."""
+
+
+class TextField(Field[str]):
+    """Text input field."""
+
+    def __init__(
+        self,
+        name: str,
+        prompt: str,
+        default: str | None = None,
+        required: bool = True,
+        validator: Callable[[str], tuple[bool, str | None]] | None = None,
+        completions: list[str] | None = None,
+        mask: bool = False,
+        help_text: str | None = None,
+    ):
+        super().__init__(name, prompt, default, required, validator, help_text)
+        self.completions = completions
+        self.mask = mask
+
+    def prompt_user(self, allow_back: bool = False) -> str | None | Any:
+        """Prompt user for text input."""
+        from data_designer.cli.ui import BACK, prompt_text_input
+
+        result = prompt_text_input(
+            self.prompt,
+            default=self.default,
+            validator=self.validator,
+            mask=self.mask,
+            completions=self.completions,
+            allow_back=allow_back,
+        )
+
+        if result is BACK:
+            return BACK
+
+        return result
+
+
+class SelectField(Field[str]):
+    """Selection field with arrow navigation."""
+
+    def __init__(
+        self,
+        name: str,
+        prompt: str,
+        options: dict[str, str],
+        default: str | None = None,
+        required: bool = True,
+        help_text: str | None = None,
+    ):
+        super().__init__(name, prompt, default, required, None, help_text)
+        self.options = options
+
+    def prompt_user(self, allow_back: bool = False) -> str | None | Any:
+        """Prompt user for selection."""
+        from data_designer.cli.ui import BACK, select_with_arrows
+
+        result = select_with_arrows(
+            self.options,
+            self.prompt,
+            default_key=self.default,
+            allow_back=allow_back,
+        )
+
+        if result is BACK:
+            return BACK
+
+        return result
+
+
+class NumericField(Field[float]):
+    """Numeric input field with range validation."""
+
+    def __init__(
+        self,
+        name: str,
+        prompt: str,
+        default: float | None = None,
+        min_value: float | None = None,
+        max_value: float | None = None,
+        required: bool = True,
+        help_text: str | None = None,
+    ):
+        self.min_value = min_value
+        self.max_value = max_value
+
+        # Build validator based on range
+        def range_validator(value: str) -> tuple[bool, str | None]:
+            if not value and not required:
+                return True, None
+            if min_value is not None and max_value is not None:
+                is_valid, parsed = validate_numeric_range(value, min_value, max_value)
+                if not is_valid:
+                    return False, f"Value must be between {min_value} and {max_value}"
+                return True, None
+            try:
+                num = float(value)
+                if min_value is not None and num < min_value:
+                    return False, f"Value must be >= {min_value}"
+                if max_value is not None and num > max_value:
+                    return False, f"Value must be <= {max_value}"
+                return True, None
+            except ValueError:
+                return False, "Must be a valid number"
+
+        super().__init__(name, prompt, default, required, range_validator, help_text)
+
+    def prompt_user(self, allow_back: bool = False) -> float | None | Any:
+        """Prompt user for numeric input."""
+        from data_designer.cli.ui import BACK, prompt_text_input
+
+        default_str = str(self.default) if self.default is not None else None
+
+        result = prompt_text_input(
+            self.prompt,
+            default=default_str,
+            validator=self.validator,
+            allow_back=allow_back,
+        )
+
+        if result is BACK:
+            return BACK
+
+        return float(result) if result else None

data_designer/cli/forms/form.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from data_designer.cli.forms.field import Field
+from data_designer.cli.ui import BACK, print_error
+
+
+class Form:
+    """A collection of fields forming a complete configuration form."""
+
+    def __init__(self, name: str, fields: list[Field]):
+        self.name = name
+        self.fields = fields
+        self._field_map = {f.name: f for f in fields}
+
+    def get_field(self, name: str) -> Field | None:
+        """Get a field by name."""
+        return self._field_map.get(name)
+
+    def get_values(self) -> dict[str, Any]:
+        """Get all field values as a dictionary."""
+        return {field.name: field.value for field in self.fields if field.value is not None}
+
+    def set_values(self, values: dict[str, Any]) -> None:
+        """Set field values from a dictionary."""
+        for name, value in values.items():
+            field = self.get_field(name)
+            if field:
+                field.value = value
+
+    def prompt_all(self, allow_back: bool = True) -> dict[str, Any] | None:
+        """Prompt user for all fields in sequence with back navigation."""
+        field_index = 0
+
+        while field_index < len(self.fields):
+            field = self.fields[field_index]
+
+            result = field.prompt_user(allow_back=allow_back and field_index > 0)
+
+            if result is None:
+                # User cancelled
+                return None
+            elif result is BACK:
+                # Go back to previous field
+                if field_index > 0:
+                    field_index -= 1
+                continue
+            else:
+                # Store value and move forward
+                try:
+                    field.value = result
+                    field_index += 1
+                except Exception as e:
+                    print_error(f"Validation error: {e}")
+                    continue
+
+        return self.get_values()

data_designer/cli/forms/model_builder.py

@@ -0,0 +1,125 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from data_designer.cli.forms.builder import FormBuilder
+from data_designer.cli.forms.field import NumericField, SelectField, TextField
+from data_designer.cli.forms.form import Form
+from data_designer.config.models import ModelConfig
+from data_designer.config.utils.constants import MAX_TEMPERATURE, MAX_TOP_P, MIN_TEMPERATURE, MIN_TOP_P
+
+
+class ModelFormBuilder(FormBuilder[ModelConfig]):
+    """Builds interactive forms for model configuration."""
+
+    def __init__(self, existing_aliases: set[str] | None = None, available_providers: list[str] | None = None):
+        super().__init__("Model Configuration")
+        self.existing_aliases = existing_aliases or set()
+        self.available_providers = available_providers or []
+
+    def create_form(self, initial_data: dict[str, Any] | None = None) -> Form:
+        """Create the model configuration form."""
+        fields = []
+
+        # Model alias
+        fields.append(
+            TextField(
+                "alias",
+                "Model alias (used in your configs)",
+                default=initial_data.get("alias") if initial_data else None,
+                required=True,
+                validator=self._validate_alias,
+            )
+        )
+
+        # Model ID
+        fields.append(
+            TextField(
+                "model",
+                "Model ID",
+                default=initial_data.get("model") if initial_data else None,
+                required=True,
+                validator=lambda x: (False, "Model ID is required") if not x else (True, None),
+            )
+        )
+
+        # Provider (if multiple available)
+        if len(self.available_providers) > 1:
+            provider_options = {p: p for p in self.available_providers}
+            fields.append(
+                SelectField(
+                    "provider",
+                    "Select provider for this model",
+                    options=provider_options,
+                    default=initial_data.get("provider", self.available_providers[0])
+                    if initial_data
+                    else self.available_providers[0],
+                )
+            )
+        elif len(self.available_providers) == 1:
+            # Single provider - will be set automatically
+            pass
+
+        # Inference parameters
+        fields.extend(
+            [
+                NumericField(
+                    "temperature",
+                    f"Temperature ({MIN_TEMPERATURE}-{MAX_TEMPERATURE})",
+                    default=initial_data.get("inference_parameters", {}).get("temperature", 0.7)
+                    if initial_data
+                    else 0.7,
+                    min_value=MIN_TEMPERATURE,
+                    max_value=MAX_TEMPERATURE,
+                ),
+                NumericField(
+                    "top_p",
+                    f"Top P ({MIN_TOP_P}-{MAX_TOP_P})",
+                    default=initial_data.get("inference_parameters", {}).get("top_p", 0.9) if initial_data else 0.9,
+                    min_value=MIN_TOP_P,
+                    max_value=MAX_TOP_P,
+                ),
+                NumericField(
+                    "max_tokens",
+                    "Max tokens",
+                    default=initial_data.get("inference_parameters", {}).get("max_tokens", 2048)
+                    if initial_data
+                    else 2048,
+                    min_value=1,
+                    max_value=100000,
+                ),
+            ]
+        )
+
+        return Form(self.title, fields)
+
+    def _validate_alias(self, alias: str) -> tuple[bool, str | None]:
+        """Validate model alias."""
+        if not alias:
+            return False, "Model alias is required"
+        if alias in self.existing_aliases:
+            return False, f"Model alias '{alias}' already exists"
+        return True, None
+
+    def build_config(self, form_data: dict[str, Any]) -> ModelConfig:
+        """Build ModelConfig from form data."""
+        # Determine provider
+        if "provider" in form_data:
+            provider = form_data["provider"]
+        elif len(self.available_providers) == 1:
+            provider = self.available_providers[0]
+        else:
+            provider = None
+
+        return ModelConfig(
+            alias=form_data["alias"],
+            model=form_data["model"],
+            provider=provider,
+            inference_parameters={
+                "temperature": form_data["temperature"],
+                "top_p": form_data["top_p"],
+                "max_tokens": int(form_data["max_tokens"]),
+                "max_parallel_requests": 4,
+            },
+        )

data_designer/cli/forms/provider_builder.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from data_designer.cli.forms.builder import FormBuilder
+from data_designer.cli.forms.field import TextField
+from data_designer.cli.forms.form import Form
+from data_designer.cli.utils import validate_url
+from data_designer.engine.model_provider import ModelProvider
+
+
+class ProviderFormBuilder(FormBuilder[ModelProvider]):
+    """Builds interactive forms for provider configuration."""
+
+    def __init__(self, existing_names: set[str] | None = None):
+        super().__init__("Provider Configuration")
+        self.existing_names = existing_names or set()
+
+    def create_form(self, initial_data: dict[str, Any] | None = None) -> Form:
+        """Create the provider configuration form."""
+        fields = [
+            TextField(
+                "name",
+                "Provider name",
+                default=initial_data.get("name") if initial_data else None,
+                required=True,
+                validator=self._validate_name,
+            ),
+            TextField(
+                "endpoint",
+                "API endpoint URL",
+                default=initial_data.get("endpoint") if initial_data else None,
+                required=True,
+                validator=self._validate_endpoint,
+            ),
+            TextField(
+                "provider_type",
+                "Provider type",
+                default=initial_data.get("provider_type", "openai") if initial_data else "openai",
+                required=True,
+            ),
+            TextField(
+                "api_key",
+                "API key or environment variable name",
+                default=initial_data.get("api_key") if initial_data else None,
+                required=False,
+            ),
+        ]
+
+        return Form(self.title, fields)
+
+    def _validate_name(self, name: str) -> tuple[bool, str | None]:
+        """Validate provider name."""
+        if not name:
+            return False, "Provider name is required"
+        if name in self.existing_names:
+            return False, f"Provider '{name}' already exists"
+        return True, None
+
+    def _validate_endpoint(self, endpoint: str) -> tuple[bool, str | None]:
+        """Validate endpoint URL."""
+        if not endpoint:
+            return False, "Endpoint URL is required"
+        if not validate_url(endpoint):
+            return False, "Invalid URL format (must start with http:// or https://)"
+        return True, None
+
+    def build_config(self, form_data: dict[str, Any]) -> ModelProvider:
+        """Build ModelProvider from form data."""
+        return ModelProvider(
+            name=form_data["name"],
+            endpoint=form_data["endpoint"],
+            provider_type=form_data["provider_type"],
+            api_key=form_data.get("api_key"),
+        )

data_designer/cli/main.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import typer
+
+from data_designer.cli.commands import list as list_cmd
+from data_designer.cli.commands import models, providers, reset
+from data_designer.config.default_model_settings import resolve_seed_default_model_settings
+from data_designer.config.utils.misc import can_run_data_designer_locally
+
+# Resolve default model settings on import to ensure they are available when the library is used.
+if can_run_data_designer_locally():
+    resolve_seed_default_model_settings()
+
+# Initialize Typer app with custom configuration
+app = typer.Typer(
+    name="data-designer",
+    help="Data Designer CLI - Configure model providers and models for synthetic data generation",
+    add_completion=False,
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Create config subcommand group
+config_app = typer.Typer(
+    name="config",
+    help="Manage configuration files",
+    no_args_is_help=True,
+)
+config_app.command(name="providers", help="Configure model providers interactively")(providers.providers_command)
+config_app.command(name="models", help="Configure models interactively")(models.models_command)
+config_app.command(name="list", help="List current configurations")(list_cmd.list_command)
+config_app.command(name="reset", help="Reset configuration files")(reset.reset_command)
+
+app.add_typer(config_app, name="config")
+
+
+def main() -> None:
+    """Main entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

data_designer/cli/repositories/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from data_designer.cli.repositories.base import ConfigRepository
+from data_designer.cli.repositories.model_repository import ModelRepository
+from data_designer.cli.repositories.provider_repository import ProviderRepository
+
+__all__ = ["ConfigRepository", "ModelRepository", "ProviderRepository"]

data_designer/cli/repositories/base.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class ConfigRepository(ABC, Generic[T]):
+    """Abstract base for configuration persistence."""
+
+    def __init__(self, config_dir: Path):
+        self.config_dir = config_dir
+
+    @property
+    @abstractmethod
+    def config_file(self) -> Path:
+        """Get the configuration file path."""
+
+    @abstractmethod
+    def load(self) -> T | None:
+        """Load configuration from file."""
+
+    @abstractmethod
+    def save(self, config: T) -> None:
+        """Save configuration to file."""
+
+    def exists(self) -> bool:
+        """Check if configuration file exists."""
+        return self.config_file.exists()
+
+    def delete(self) -> None:
+        """Delete configuration file."""
+        if self.exists():
+            self.config_file.unlink()

data_designer/cli/repositories/model_repository.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from data_designer.cli.repositories.base import ConfigRepository
+from data_designer.config.models import ModelConfig
+from data_designer.config.utils.constants import MODEL_CONFIGS_FILE_NAME
+from data_designer.config.utils.io_helpers import load_config_file, save_config_file
+
+
+class ModelConfigRegistry(BaseModel):
+    """Registry for model configurations."""
+
+    model_configs: list[ModelConfig]
+
+
+class ModelRepository(ConfigRepository[ModelConfigRegistry]):
+    """Repository for model configurations."""
+
+    @property
+    def config_file(self) -> Path:
+        """Get the model configuration file path."""
+        return self.config_dir / MODEL_CONFIGS_FILE_NAME
+
+    def load(self) -> ModelConfigRegistry | None:
+        """Load model configuration from file."""
+        if not self.exists():
+            return None
+
+        try:
+            config_dict = load_config_file(self.config_file)
+            return ModelConfigRegistry.model_validate(config_dict)
+        except Exception:
+            return None
+
+    def save(self, config: ModelConfigRegistry) -> None:
+        """Save model configuration to file."""
+        config_dict = config.model_dump(mode="json", exclude_none=True)
+        save_config_file(self.config_file, config_dict)

data_designer/cli/repositories/provider_repository.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from data_designer.cli.repositories.base import ConfigRepository
+from data_designer.config.models import ModelProvider
+from data_designer.config.utils.constants import MODEL_PROVIDERS_FILE_NAME
+from data_designer.config.utils.io_helpers import load_config_file, save_config_file
+
+
+class ModelProviderRegistry(BaseModel):
+    """Registry for model provider configurations."""
+
+    providers: list[ModelProvider]
+    default: str | None = None
+
+
+class ProviderRepository(ConfigRepository[ModelProviderRegistry]):
+    """Repository for provider configurations."""
+
+    @property
+    def config_file(self) -> Path:
+        """Get the provider configuration file path."""
+        return self.config_dir / MODEL_PROVIDERS_FILE_NAME
+
+    def load(self) -> ModelProviderRegistry | None:
+        """Load provider configuration from file."""
+        if not self.exists():
+            return None
+
+        try:
+            config_dict = load_config_file(self.config_file)
+            return ModelProviderRegistry.model_validate(config_dict)
+        except Exception:
+            return None
+
+    def save(self, config: ModelProviderRegistry) -> None:
+        """Save provider configuration to file."""
+        config_dict = config.model_dump(mode="json", exclude_none=True)
+        save_config_file(self.config_file, config_dict)

data_designer/cli/services/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from data_designer.cli.services.model_service import ModelService
+from data_designer.cli.services.provider_service import ProviderService
+
+__all__ = ["ModelService", "ProviderService"]