data-designer 0.3.8rc2__py3-none-any.whl → 0.4.0rc1__py3-none-any.whl

data_designer/plugin_manager.py

@@ -1,78 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from enum import Enum
-from typing import TYPE_CHECKING, TypeAlias
-
-from data_designer.plugins.plugin import PluginType
-from data_designer.plugins.registry import PluginRegistry
-
-if TYPE_CHECKING:
-    from data_designer.plugins.plugin import Plugin
-
-
-class PluginManager:
-    def __init__(self):
-        self._plugin_registry = PluginRegistry()
-
-    def get_column_generator_plugins(self) -> list[Plugin]:
-        """Get all column generator plugins.
-
-        Returns:
-            A list of all column generator plugins.
-        """
-        return self._plugin_registry.get_plugins(PluginType.COLUMN_GENERATOR)
-
-    def get_column_generator_plugin_if_exists(self, plugin_name: str) -> Plugin | None:
-        """Get a column generator plugin by name if it exists.
-
-        Args:
-            plugin_name: The name of the plugin to retrieve.
-
-        Returns:
-            The plugin if found, otherwise None.
-        """
-        if self._plugin_registry.plugin_exists(plugin_name):
-            return self._plugin_registry.get_plugin(plugin_name)
-
-    def get_plugin_column_types(self, enum_type: type[Enum]) -> list[Enum]:
-        """Get a list of plugin column types.
-
-        Args:
-            enum_type: The enum type to use for plugin entries.
-
-        Returns:
-            A list of plugin column types.
-        """
-        type_list = []
-        for plugin in self._plugin_registry.get_plugins(PluginType.COLUMN_GENERATOR):
-            type_list.append(enum_type(plugin.name))
-        return type_list
-
-    def inject_into_column_config_type_union(self, column_config_type: type[TypeAlias]) -> type[TypeAlias]:
-        """Inject plugins into the column config type.
-
-        Args:
-            column_config_type: The column config type to inject plugins into.
-
-        Returns:
-            The column config type with plugins injected.
-        """
-        column_config_type = self._plugin_registry.add_plugin_types_to_union(
-            column_config_type, PluginType.COLUMN_GENERATOR
-        )
-        return column_config_type
-
-    def inject_into_seed_source_type_union(self, seed_source_type: type[TypeAlias]) -> type[TypeAlias]:
-        """Inject plugins into the seed source type.
-
-        Args:
-            seed_source_type: The seed source type to inject plugins into.
-
-        Returns:
-            The seed source type with plugins injected.
-        """
-        seed_source_type = self._plugin_registry.add_plugin_types_to_union(seed_source_type, PluginType.SEED_READER)
-        return seed_source_type

data_designer/plugins/__init__.py

@@ -1,8 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from data_designer.plugins.plugin import Plugin, PluginType
-
-__all__ = ["Plugin", "PluginType"]

data_designer/plugins/errors.py

@@ -1,15 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from data_designer.errors import DataDesignerError
-
-
-class PluginLoadError(DataDesignerError): ...
-
-
-class PluginRegistrationError(DataDesignerError): ...
-
-
-class PluginNotFoundError(DataDesignerError): ...

data_designer/plugins/plugin.py

@@ -1,141 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import ast
-import importlib
-import importlib.util
-from enum import Enum
-from functools import cached_property
-from typing import Literal, get_origin
-
-from pydantic import BaseModel, Field, field_validator, model_validator
-from typing_extensions import Self
-
-from data_designer.config.base import ConfigBase
-from data_designer.plugins.errors import PluginLoadError
-
-
-class PluginType(str, Enum):
-    COLUMN_GENERATOR = "column-generator"
-    SEED_READER = "seed-reader"
-
-    @property
-    def discriminator_field(self) -> str:
-        if self == PluginType.COLUMN_GENERATOR:
-            return "column_type"
-        elif self == PluginType.SEED_READER:
-            return "seed_type"
-        else:
-            raise ValueError(f"Invalid plugin type: {self.value}")
-
-    @property
-    def display_name(self) -> str:
-        return self.value.replace("-", " ")
-
-
-def _get_module_and_object_names(fully_qualified_object: str) -> tuple[str, str]:
-    try:
-        module_name, object_name = fully_qualified_object.rsplit(".", 1)
-    except ValueError:
-        # If fully_qualified_object does not have any periods, the rsplit call will return
-        # a list of length 1 and the variable assignment above will raise ValueError
-        raise PluginLoadError("Expected a fully-qualified object name, e.g. 'my_plugin.config.MyConfig'")
-
-    return module_name, object_name
-
-
-def _check_class_exists_in_file(filepath: str, class_name: str) -> None:
-    try:
-        with open(filepath, "r") as file:
-            source = file.read()
-    except FileNotFoundError:
-        raise PluginLoadError(f"Could not read source code at {filepath!r}")
-
-    tree = ast.parse(source)
-    for node in ast.walk(tree):
-        if isinstance(node, ast.ClassDef) and node.name == class_name:
-            return None
-
-    raise PluginLoadError(f"Could not find class named {class_name!r} in {filepath!r}")
-
-
-class Plugin(BaseModel):
-    impl_qualified_name: str = Field(
-        ...,
-        description="The fully-qualified name of the implementation class object, e.g. 'my_plugin.generator.MyColumnGenerator'",
-    )
-    config_qualified_name: str = Field(
-        ..., description="The fully-qualified name o the config class object, e.g. 'my_plugin.config.MyConfig'"
-    )
-    plugin_type: PluginType = Field(..., description="The type of plugin")
-
-    @property
-    def config_type_as_class_name(self) -> str:
-        return self.enum_key_name.title().replace("_", "")
-
-    @property
-    def enum_key_name(self) -> str:
-        return self.name.replace("-", "_").upper()
-
-    @property
-    def name(self) -> str:
-        return self.config_cls.model_fields[self.discriminator_field].default
-
-    @property
-    def discriminator_field(self) -> str:
-        return self.plugin_type.discriminator_field
-
-    @field_validator("impl_qualified_name", "config_qualified_name", mode="after")
-    @classmethod
-    def validate_class_name(cls, value: str) -> str:
-        module_name, object_name = _get_module_and_object_names(value)
-        try:
-            spec = importlib.util.find_spec(module_name)
-        except:
-            raise PluginLoadError(f"Could not find module {module_name!r}")
-
-        if spec is None or spec.origin is None:
-            raise PluginLoadError(f"Error finding source for module {module_name!r}")
-
-        _check_class_exists_in_file(spec.origin, object_name)
-
-        return value
-
-    @model_validator(mode="after")
-    def validate_discriminator_field(self) -> Self:
-        _, cfg = _get_module_and_object_names(self.config_qualified_name)
-        field = self.plugin_type.discriminator_field
-        if field not in self.config_cls.model_fields:
-            raise ValueError(f"Discriminator field {field!r} not found in config class {cfg!r}")
-        field_info = self.config_cls.model_fields[field]
-        if get_origin(field_info.annotation) is not Literal:
-            raise ValueError(f"Field {field!r} of {cfg!r} must be a Literal type, not {field_info.annotation!r}.")
-        if not isinstance(field_info.default, str):
-            raise ValueError(f"The default of {field!r} must be a string, not {type(field_info.default)!r}.")
-        enum_key = field_info.default.replace("-", "_").upper()
-        if not enum_key.isidentifier():
-            raise ValueError(
-                f"The default value {field_info.default!r} for discriminator field {field!r} "
-                f"cannot be converted to a valid enum key. The converted key {enum_key!r} "
-                f"must be a valid Python identifier."
-            )
-        return self
-
-    @cached_property
-    def config_cls(self) -> type[ConfigBase]:
-        return self._load(self.config_qualified_name)
-
-    @cached_property
-    def impl_cls(self) -> type:
-        return self._load(self.impl_qualified_name)
-
-    @staticmethod
-    def _load(fully_qualified_object: str) -> type:
-        module_name, object_name = _get_module_and_object_names(fully_qualified_object)
-        module = importlib.import_module(module_name)
-        try:
-            return getattr(module, object_name)
-        except AttributeError:
-            raise PluginLoadError(f"Could not find class {object_name!r} in module {module_name!r}")

data_designer/plugins/registry.py

@@ -1,88 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-import logging
-import os
-import threading
-from importlib.metadata import entry_points
-from typing import TypeAlias
-
-from typing_extensions import Self
-
-from data_designer.plugins.errors import PluginNotFoundError
-from data_designer.plugins.plugin import Plugin, PluginType
-
-logger = logging.getLogger(__name__)
-
-
-PLUGINS_DISABLED = os.getenv("DISABLE_DATA_DESIGNER_PLUGINS", "false").lower() == "true"
-
-
-class PluginRegistry:
-    _instance = None
-    _plugins_discovered = False
-    _lock = threading.Lock()
-
-    _plugins: dict[str, Plugin] = {}
-
-    def __init__(self):
-        with self._lock:
-            if not self._plugins_discovered:
-                self._discover()
-
-    @classmethod
-    def reset(cls) -> None:
-        with cls._lock:
-            cls._instance = None
-            cls._plugins_discovered = False
-            cls._plugins = {}
-
-    def add_plugin_types_to_union(self, type_union: type[TypeAlias], plugin_type: PluginType) -> type[TypeAlias]:
-        for plugin in self.get_plugins(plugin_type):
-            if plugin.config_cls not in type_union.__args__:
-                type_union |= plugin.config_cls
-        return type_union
-
-    def get_plugin(self, plugin_name: str) -> Plugin:
-        if plugin_name not in self._plugins:
-            raise PluginNotFoundError(f"Plugin {plugin_name!r} not found.")
-        return self._plugins[plugin_name]
-
-    def get_plugins(self, plugin_type: PluginType) -> list[Plugin]:
-        return [plugin for plugin in self._plugins.values() if plugin.plugin_type == plugin_type]
-
-    def get_plugin_names(self, plugin_type: PluginType) -> list[str]:
-        return [plugin.name for plugin in self.get_plugins(plugin_type)]
-
-    def num_plugins(self, plugin_type: PluginType) -> int:
-        return len(self.get_plugins(plugin_type))
-
-    def plugin_exists(self, plugin_name: str) -> bool:
-        return plugin_name in self._plugins
-
-    def _discover(self) -> Self:
-        if PLUGINS_DISABLED:
-            return self
-        for ep in entry_points(group="data_designer.plugins"):
-            try:
-                plugin = ep.load()
-                if isinstance(plugin, Plugin):
-                    logger.info(
-                        f"🔌 Plugin discovered ➜ {plugin.plugin_type.display_name} "
-                        f"{plugin.enum_key_name} is now available ⚡️"
-                    )
-                    self._plugins[plugin.name] = plugin
-            except Exception as e:
-                logger.warning(f"🛑 Failed to load plugin from entry point {ep.name!r}: {e}")
-        self._plugins_discovered = True
-        return self
-
-    def __new__(cls, *args, **kwargs):
-        """Plugin manager is a singleton."""
-        if not cls._instance:
-            with cls._lock:
-                if not cls._instance:
-                    cls._instance = super().__new__(cls)
-        return cls._instance

data_designer/plugins/testing/__init__.py

@@ -1,10 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from data_designer.plugins.testing.utils import assert_valid_plugin
-
-__all__ = [
-    assert_valid_plugin.__name__,
-]

data_designer/plugins/testing/stubs.py

@@ -1,116 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from typing import Literal
-
-from data_designer.config.base import ConfigBase
-from data_designer.config.column_configs import SingleColumnConfig
-from data_designer.engine.column_generators.generators.base import ColumnGeneratorCellByCell
-from data_designer.plugins.plugin import Plugin, PluginType
-
-MODULE_NAME = __name__
-
-
-class ValidTestConfig(SingleColumnConfig):
-    """Valid config for testing plugin creation."""
-
-    column_type: Literal["test-generator"] = "test-generator"
-    name: str
-
-
-class ValidTestTask(ColumnGeneratorCellByCell[ValidTestConfig]):
-    """Valid task for testing plugin creation."""
-
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-class ConfigWithoutDiscriminator(ConfigBase):
-    some_field: str
-
-
-class ConfigWithStringField(ConfigBase):
-    column_type: str = "test-generator"
-
-
-class ConfigWithNonStringDefault(ConfigBase):
-    column_type: Literal["test-generator"] = 123  # type: ignore
-
-
-class ConfigWithInvalidKey(ConfigBase):
-    column_type: Literal["invalid-key-!@#"] = "invalid-key-!@#"
-
-
-class StubPluginConfigA(SingleColumnConfig):
-    column_type: Literal["test-plugin-a"] = "test-plugin-a"
-
-
-class StubPluginConfigB(SingleColumnConfig):
-    column_type: Literal["test-plugin-b"] = "test-plugin-b"
-
-
-class StubPluginTaskA(ColumnGeneratorCellByCell[StubPluginConfigA]):
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-class StubPluginTaskB(ColumnGeneratorCellByCell[StubPluginConfigB]):
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-# Stub plugins requiring different combinations of resources
-
-
-class StubPluginConfigModels(SingleColumnConfig):
-    column_type: Literal["test-plugin-models"] = "test-plugin-models"
-
-
-class StubPluginConfigModelsAndBlobs(SingleColumnConfig):
-    column_type: Literal["test-plugin-models-and-blobs"] = "test-plugin-models-and-blobs"
-
-
-class StubPluginConfigBlobsAndSeeds(SingleColumnConfig):
-    column_type: Literal["test-plugin-blobs-and-seeds"] = "test-plugin-blobs-and-seeds"
-
-
-class StubPluginTaskModels(ColumnGeneratorCellByCell[StubPluginConfigModels]):
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-class StubPluginTaskModelsAndBlobs(ColumnGeneratorCellByCell[StubPluginConfigModelsAndBlobs]):
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-class StubPluginTaskBlobsAndSeeds(ColumnGeneratorCellByCell[StubPluginConfigBlobsAndSeeds]):
-    def generate(self, data: dict) -> dict:
-        return data
-
-
-plugin_none = Plugin(
-    config_qualified_name=f"{MODULE_NAME}.StubPluginConfigA",
-    impl_qualified_name=f"{MODULE_NAME}.StubPluginTaskA",
-    plugin_type=PluginType.COLUMN_GENERATOR,
-)
-
-plugin_models = Plugin(
-    config_qualified_name=f"{MODULE_NAME}.StubPluginConfigModels",
-    impl_qualified_name=f"{MODULE_NAME}.StubPluginTaskModels",
-    plugin_type=PluginType.COLUMN_GENERATOR,
-)
-
-plugin_models_and_blobs = Plugin(
-    config_qualified_name=f"{MODULE_NAME}.StubPluginConfigModelsAndBlobs",
-    impl_qualified_name=f"{MODULE_NAME}.StubPluginTaskModelsAndBlobs",
-    plugin_type=PluginType.COLUMN_GENERATOR,
-)
-
-plugin_blobs_and_seeds = Plugin(
-    config_qualified_name=f"{MODULE_NAME}.StubPluginConfigBlobsAndSeeds",
-    impl_qualified_name=f"{MODULE_NAME}.StubPluginTaskBlobsAndSeeds",
-    plugin_type=PluginType.COLUMN_GENERATOR,
-)

data_designer/plugins/testing/utils.py

@@ -1,20 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-from __future__ import annotations
-
-from data_designer.config.base import ConfigBase
-from data_designer.engine.configurable_task import ConfigurableTask
-from data_designer.engine.resources.seed_reader import SeedReader
-from data_designer.plugins.plugin import Plugin, PluginType
-
-
-def assert_valid_plugin(plugin: Plugin) -> None:
-    assert issubclass(plugin.config_cls, ConfigBase), "Plugin config class is not a subclass of ConfigBase"
-
-    if plugin.plugin_type == PluginType.COLUMN_GENERATOR:
-        assert issubclass(plugin.impl_cls, ConfigurableTask), (
-            "Column generator plugin impl class must be a subclass of ConfigurableTask"
-        )
-    elif plugin.plugin_type == PluginType.SEED_READER:
-        assert issubclass(plugin.impl_cls, SeedReader), "Seed reader plugin impl class must be a subclass of SeedReader"