nvidia-nat-data-flywheel 1.3.0a20250828__py3-none-any.whl

nat/plugins/data_flywheel/observability/processor/trace_conversion/trace_adapter_registry.py

@@ -0,0 +1,255 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from collections.abc import Callable
+from functools import reduce
+from typing import Any
+
+from nat.plugins.data_flywheel.observability.schema.trace_container import TraceContainer
+
+logger = logging.getLogger(__name__)
+
+
+class TraceAdapterRegistry:
+    """Registry for trace source to target type conversions.
+
+    Maintains schema detection through Pydantic unions while enabling dynamic registration
+    of converter functions for different trace source types.
+    """
+
+    _registered_types: dict[type, dict[type, Callable]] = {}  # source_type -> {target_type -> converter}
+    _union_cache: Any = None
+
+    @classmethod
+    def register_adapter(cls, trace_source_model: type) -> Callable[[Callable], Callable]:
+        """Register adapter with a trace source Pydantic model.
+
+        The model defines the schema for union-based detection, allowing automatic
+        schema matching without explicit framework/provider specification.
+
+        Args:
+            trace_source_model (type): Pydantic model class that defines the trace source schema
+                               (e.g., OpenAITraceSource, NIMTraceSource, CustomTraceSource)
+
+        Returns:
+            Callable: Decorator function that registers the converter
+        """
+
+        def decorator(func):
+            return_type = func.__annotations__.get('return')
+
+            # Validate return type annotation exists and is meaningful
+            if return_type is None:
+                raise ValueError(f"Converter function '{func.__name__}' must have a return type annotation.\n"
+                                 f"Example: def {func.__name__}(trace: TraceContainer) -> DFWESRecord:")
+
+            # Initialize nested dict if needed
+            if trace_source_model not in cls._registered_types:
+                cls._registered_types[trace_source_model] = {}
+
+            # Store converter: source_type -> target_type -> converter_func
+            cls._registered_types[trace_source_model][return_type] = func
+
+            # Immediately rebuild union and update TraceContainer model
+            cls._rebuild_union()
+
+            logger.debug("Registered %s -> %s converter",
+                         trace_source_model.__name__,
+                         getattr(return_type, '__name__', str(return_type)))
+            return func
+
+        return decorator
+
+    @classmethod
+    def convert(cls, trace_container: TraceContainer, to_type: type) -> Any:
+        """Convert trace to target type using registered converter function.
+
+        Args:
+            trace_container (TraceContainer): TraceContainer with source data to convert
+            to_type (type): Target type to convert to
+
+        Returns:
+            Converted object of to_type
+
+        Raises:
+            ValueError: If no converter is registered for source->target combination
+        """
+        source_type = type(trace_container.source)
+
+        # Look up converter: source_type -> target_type -> converter_func
+        source_converters = cls._registered_types.get(source_type, {})
+        converter = source_converters.get(to_type)
+
+        if not converter:
+            available_targets = list(source_converters.keys()) if source_converters else []
+            available_target_names = [getattr(t, '__name__', str(t)) for t in available_targets]
+            raise ValueError(
+                f"No converter from {source_type.__name__} to {getattr(to_type, '__name__', str(to_type))}. "
+                f"Available targets: {available_target_names}")
+
+        return converter(trace_container)
+
+    @classmethod
+    def get_adapter(cls, trace_container: TraceContainer, to_type: type) -> Callable | None:
+        """Get the converter function for a given trace source and target type.
+
+        Args:
+            trace_container (TraceContainer): TraceContainer with source data
+            to_type (type): Target type to convert to
+
+        Returns:
+            Converter function if registered, None if not found
+        """
+        source_type = type(trace_container.source)
+        return cls._registered_types.get(source_type, {}).get(to_type)
+
+    @classmethod
+    def get_current_union(cls) -> type:
+        """Get the current source union with all registered source types.
+
+        Returns:
+            type: Union type containing all registered trace source types
+        """
+        if cls._union_cache is None:
+            cls._rebuild_union()
+        return cls._union_cache
+
+    @classmethod
+    def _rebuild_union(cls):
+        """Rebuild the union with all registered trace source types."""
+
+        # Get all registered source types (dictionary keys)
+        all_schema_types = set(cls._registered_types.keys())
+
+        # Create union from source types (used for Pydantic schema detection)
+        if len(all_schema_types) == 0:
+            # No types registered yet - use Any as permissive fallback
+            cls._union_cache = Any
+        elif len(all_schema_types) == 1:
+            cls._union_cache = next(iter(all_schema_types))
+        else:
+            # Sort types by name to ensure consistent order
+            sorted_types = sorted(all_schema_types, key=lambda t: t.__name__)
+            # Create Union from multiple types using reduce
+            cls._union_cache = reduce(lambda a, b: a | b, sorted_types)
+
+        logger.debug("Rebuilt source union with %d registered source types: %s",
+                     len(all_schema_types), [t.__name__ for t in all_schema_types])
+
+        # Update TraceContainer model with new union
+        cls._update_trace_source_model()
+
+    @classmethod
+    def _update_trace_source_model(cls):
+        """Update the TraceContainer model to use the current dynamic union."""
+        try:
+            # Update the source field annotation to use current union
+            if hasattr(TraceContainer, '__annotations__'):
+                TraceContainer.__annotations__['source'] = cls._union_cache
+
+                # Force Pydantic to rebuild the model with new annotations
+                TraceContainer.model_rebuild()
+                logger.debug("Updated TraceContainer model with new union type")
+        except Exception as e:
+            logger.warning("Failed to update TraceContainer model: %s", e)
+
+    @classmethod
+    def unregister_adapter(cls, source_type: type, target_type: type) -> bool:
+        """Unregister a specific adapter.
+
+        Args:
+            source_type (type): The trace source type
+            target_type (type): The target conversion type
+
+        Returns:
+            bool: True if adapter was found and removed, False if not found
+        """
+        if source_type not in cls._registered_types:
+            return False
+
+        target_converters = cls._registered_types[source_type]
+        if target_type not in target_converters:
+            return False
+
+        # Remove the specific converter
+        del target_converters[target_type]
+
+        # Clean up empty source entry
+        if not target_converters:
+            del cls._registered_types[source_type]
+
+        # Rebuild union since registered types changed
+        cls._rebuild_union()
+
+        logger.debug("Unregistered %s -> %s converter",
+                     source_type.__name__,
+                     getattr(target_type, '__name__', str(target_type)))
+        return True
+
+    @classmethod
+    def unregister_all_adapters(cls, source_type: type) -> int:
+        """Unregister all adapters for a given source type.
+
+        Args:
+            source_type (type): The trace source type to remove all converters for
+
+        Returns:
+            int: Number of converters removed
+        """
+        if source_type not in cls._registered_types:
+            return 0
+
+        removed_count = len(cls._registered_types[source_type])
+        del cls._registered_types[source_type]
+
+        # Rebuild union since registered types changed
+        cls._rebuild_union()
+
+        logger.debug("Unregistered all %d converters for %s", removed_count, source_type.__name__)
+        return removed_count
+
+    @classmethod
+    def clear_registry(cls) -> int:
+        """Clear all registered adapters. Useful for testing cleanup.
+
+        Returns:
+            int: Total number of converters removed
+        """
+        total_removed = sum(len(converters) for converters in cls._registered_types.values())
+        cls._registered_types.clear()
+        cls._union_cache = None
+
+        # Rebuild union (will be empty now)
+        cls._rebuild_union()
+
+        logger.debug("Cleared registry - removed %d total converters", total_removed)
+        return total_removed
+
+    @classmethod
+    def list_registered_types(cls) -> dict[type, dict[type, Callable]]:
+        """List all registered conversions: source_type -> {target_type -> converter}.
+
+        Returns:
+            dict[type, dict[type, Callable]]: Nested dict mapping source types to their available target conversions
+        """
+        return cls._registered_types
+
+
+# Convenience functions for adapter management
+register_adapter = TraceAdapterRegistry.register_adapter
+unregister_adapter = TraceAdapterRegistry.unregister_adapter
+unregister_all_adapters = TraceAdapterRegistry.unregister_all_adapters
+clear_registry = TraceAdapterRegistry.clear_registry

nat/plugins/data_flywheel/observability/register.py

@@ -0,0 +1,61 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_telemetry_exporter
+from nat.data_models.telemetry_exporter import TelemetryExporterBaseConfig
+from nat.observability.mixin.batch_config_mixin import BatchConfigMixin
+from nat.plugins.data_flywheel.observability.schema.sink.elasticsearch import ContractVersion
+
+logger = logging.getLogger(__name__)
+
+
+class DFWElasticsearchTelemetryExporter(TelemetryExporterBaseConfig,
+                                        BatchConfigMixin,
+                                        name="data_flywheel_elasticsearch"):
+    """A telemetry exporter to transmit traces to NVIDIA Data Flywheel via Elasticsearch."""
+
+    client_id: str = Field(description="The data flywheel client ID.")
+    index: str = Field(description="The elasticsearch index name.")
+    endpoint: str = Field(description="The elasticsearch endpoint.")
+    contract_version: ContractVersion = Field(default=ContractVersion.V1_1,
+                                              description="The DFW Elasticsearch record schema version to use.")
+    username: str | None = Field(default=None, description="The elasticsearch username.")
+    password: str | None = Field(default=None, description="The elasticsearch password.")
+    headers: dict | None = Field(default=None, description="Additional headers for elasticsearch requests.")
+
+
+@register_telemetry_exporter(config_type=DFWElasticsearchTelemetryExporter)
+async def dfw_elasticsearch_telemetry_exporter(config: DFWElasticsearchTelemetryExporter, _builder: Builder):
+    # pylint: disable=import-outside-toplevel
+    from nat.plugins.data_flywheel.observability.exporter.dfw_elasticsearch_exporter import DFWElasticsearchExporter
+
+    elasticsearch_auth = (config.username, config.password) if config.username and config.password else ()
+
+    yield DFWElasticsearchExporter(client_id=config.client_id,
+                                   index=config.index,
+                                   endpoint=config.endpoint,
+                                   elasticsearch_auth=elasticsearch_auth,
+                                   headers=config.headers,
+                                   contract_version=config.contract_version,
+                                   batch_size=config.batch_size,
+                                   flush_interval=config.flush_interval,
+                                   max_queue_size=config.max_queue_size,
+                                   drop_on_overflow=config.drop_on_overflow,
+                                   shutdown_timeout=config.shutdown_timeout)

nat/plugins/data_flywheel/observability/schema/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nat/plugins/data_flywheel/observability/schema/provider/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

nat/plugins/data_flywheel/observability/schema/provider/nim_trace_source.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+from nat.plugins.data_flywheel.observability.schema.provider.openai_trace_source import OpenAITraceSourceBase
+
+logger = logging.getLogger(__name__)
+
+
+class NIMTraceSource(OpenAITraceSourceBase):
+    pass

nat/plugins/data_flywheel/observability/schema/provider/openai_message.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import Field
+
+
+# LangChain message models for validation
+class OpenAIMessage(BaseModel):
+    content: str | None = Field(default=None, description="The content of the message.")
+    additional_kwargs: dict[str, Any] = Field(default_factory=dict, description="Additional kwargs for the message.")
+    response_metadata: dict[str, Any] = Field(default_factory=dict, description="Response metadata for the message.")
+    type: str = Field(description="The type of the message.")
+    name: str | None = Field(default=None, description="The name of the message.")
+    id: str | None = None
+    example: bool = Field(default=False, description="Whether the message is an example.")
+    tool_call_id: str | None = Field(default=None, description="The tool call ID for the message.")

nat/plugins/data_flywheel/observability/schema/provider/openai_trace_source.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import Any
+from typing import TypeVar
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import field_validator
+
+from nat.data_models.intermediate_step import ToolSchema
+from nat.plugins.data_flywheel.observability.schema.provider.openai_message import OpenAIMessage
+from nat.plugins.data_flywheel.observability.schema.trace_source_base import TraceSourceBase
+from nat.plugins.data_flywheel.observability.utils.deserialize import deserialize_span_attribute
+
+ProviderT = TypeVar("ProviderT")
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIMetadata(BaseModel):
+    """Metadata for the OpenAITraceSource."""
+
+    tools_schema: list[ToolSchema] | None = Field(default=None,
+                                                  description="The tools schema for the OpenAITraceSource.")
+    chat_responses: list[dict[str, Any]] | None = Field(default=None,
+                                                        description="The chat responses for the OpenAITraceSource.")
+
+
+class OpenAITraceSourceBase(TraceSourceBase):
+    """Base class for the OpenAITraceSource."""
+
+    input_value: list[OpenAIMessage]
+    metadata: OpenAIMetadata
+
+    @field_validator("input_value", mode="before")
+    @classmethod
+    def validate_input_value(cls, v: Any) -> list[OpenAIMessage]:
+        """Validate the input value for the OpenAITraceSource."""
+        if v is None:
+            raise ValueError("Input value is required")
+
+        # Handle string input (JSON string)
+        if isinstance(v, str):
+            v = deserialize_span_attribute(v)
+
+        # Handle dict input (single message)
+        if isinstance(v, dict):
+            v = [v]
+
+        # Validate list of messages
+        if isinstance(v, list):
+            validated_messages = []
+            for msg in v:
+                if isinstance(msg, dict):
+                    validated_messages.append(OpenAIMessage(**msg))
+                elif isinstance(msg, OpenAIMessage):
+                    validated_messages.append(msg)
+                else:
+                    raise ValueError(f"Invalid message format: {msg}")
+            return validated_messages
+
+        raise ValueError(f"Invalid input_value format: {v}")
+
+    @field_validator("metadata", mode="before")
+    @classmethod
+    def validate_metadata(cls, v: Any) -> "OpenAIMetadata | dict[str, Any]":
+        """Normalize metadata supplied as OpenAIMetadata, dict, or JSON string."""
+        if v is None:
+            return {}
+        if isinstance(v, OpenAIMetadata):
+            return v
+        if isinstance(v, str):
+            v = deserialize_span_attribute(v)
+        if isinstance(v, dict):
+            return v
+        raise ValueError(f"Invalid metadata format: {v!r}")
+
+
+class OpenAITraceSource(OpenAITraceSourceBase):
+    """Concrete OpenAI trace source."""
+    pass

nat/plugins/data_flywheel/observability/schema/register.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=unused-import
+# flake8: noqa
+# isort:skip_file
+
+# Import any destinations contract schemas which need to be automatically registered here
+from nat.plugins.data_flywheel.observability.schema.sink.elasticsearch import dfw_es_record

nat/plugins/data_flywheel/observability/schema/schema_registry.py

@@ -0,0 +1,144 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T', bound=BaseModel)
+
+
+class SchemaRegistry:
+    """Registry for managing schema contracts and versions."""
+
+    _schemas: dict[str, dict[str, type[BaseModel]]] = {}
+
+    @classmethod
+    def register(cls, name: str, version: str):
+        """Decorator to register a schema class for a specific destination and version.
+
+        Args:
+            name (str): The destination/exporter name (e.g., "elasticsearch")
+            version (str): The version string (e.g., "1.0", "1.1")
+
+        Returns:
+            The decorator function
+        """
+
+        def decorator(schema_cls: type[T]) -> type[T]:
+            if name not in cls._schemas:
+                cls._schemas[name] = {}
+
+            if version in cls._schemas[name]:
+                logger.warning("Overriding existing schema for %s:%s", name, version)
+
+            cls._schemas[name][version] = schema_cls
+            logger.debug("Registered schema %s for %s:%s", schema_cls.__name__, name, version)
+
+            return schema_cls
+
+        return decorator
+
+    @classmethod
+    def get_schema(cls, name: str, version: str) -> type[BaseModel]:
+        """Get the schema class for a specific destination and version.
+
+        Args:
+            name (str): The destination/exporter name (e.g., "elasticsearch")
+            version (str): The version string to look up
+
+        Returns:
+            type[BaseModel]: The Pydantic model class for the requested destination and version
+
+        Raises:
+            KeyError: If the name:version combination is not registered.
+        """
+        if name not in cls._schemas:
+            available_destinations = list(cls._schemas.keys())
+            raise KeyError(f"Destination '{name}' not found. "
+                           f"Available destinations: {available_destinations}")
+
+        if version not in cls._schemas[name]:
+            available_versions = list(cls._schemas[name].keys())
+            raise KeyError(f"Version '{version}' not found for destination '{name}'. "
+                           f"Available versions: {available_versions}")
+
+        return cls._schemas[name][version]
+
+    @classmethod
+    def get_available_schemas(cls) -> list[str]:
+        """Get all registered schema name:version combinations.
+
+        Returns:
+            list[str]: List of registered schema keys in "name:version" format
+        """
+        schemas = []
+        for name, versions in cls._schemas.items():
+            for version in versions.keys():
+                schemas.append(f"{name}:{version}")
+        return schemas
+
+    @classmethod
+    def get_schemas_for_destination(cls, name: str) -> list[str]:
+        """Get all registered schema versions for a specific destination.
+
+        Args:
+            name (str): The destination/exporter name
+
+        Returns:
+            list[str]: List of version strings for the specified destination
+        """
+        if name not in cls._schemas:
+            return []
+        return list(cls._schemas[name].keys())
+
+    @classmethod
+    def get_available_destinations(cls) -> list[str]:
+        """Get all registered destination names.
+
+        Returns:
+            list[str]: List of registered destination names
+        """
+        return list(cls._schemas.keys())
+
+    @classmethod
+    def is_registered(cls, name: str, version: str) -> bool:
+        """Check if a name:version combination is registered.
+
+        Args:
+            name (str): The destination/exporter name
+            version (str): The version string to check
+
+        Returns:
+            bool: True if the name:version is registered, False otherwise
+        """
+        return name in cls._schemas and version in cls._schemas[name]
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered schemas."""
+        cls._schemas.clear()
+
+
+# Convenience aliases for more concise usage
+register_schema = SchemaRegistry.register
+get_schema = SchemaRegistry.get_schema
+get_available_schemas = SchemaRegistry.get_available_schemas
+get_available_destinations = SchemaRegistry.get_available_destinations
+get_schemas_for_destination = SchemaRegistry.get_schemas_for_destination
+is_registered = SchemaRegistry.is_registered

nat/plugins/data_flywheel/observability/schema/sink/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.