nvidia-nat 1.4.0a20251112__py3-none-any.whl → 1.4.0a20260113__py3-none-any.whl

nat/finetuning/utils/parsers/common.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, 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.
+"""Common utilities shared across all parser implementations."""
+
+import json
+from typing import Any
+
+from nat.data_models.intermediate_step import IntermediateStep
+
+
+def extract_content(data: Any) -> str:
+    """Extract string content from various data formats.
+
+    This is a shared utility used by all parser implementations.
+
+    Args:
+        data: The data to extract content from. Can be a string, dict, list,
+              or object with content/text attributes.
+
+    Returns:
+        The extracted content as a string.
+    """
+    if isinstance(data, str):
+        return data
+    elif isinstance(data, dict):
+        # Try common content fields
+        for key in ["content", "text", "message", "output"]:
+            if key in data:
+                return str(data[key])
+        # Check for blocks format
+        if "blocks" in data:
+            blocks = data["blocks"]
+            if isinstance(blocks, list):
+                return ''.join(block.get('text', '') if isinstance(block, dict) else str(block) for block in blocks)
+        # Fallback to JSON representation
+        return json.dumps(data)
+    elif isinstance(data, list):
+        # Join list items if they're strings
+        if all(isinstance(item, str) for item in data):
+            return "\n".join(data)
+        # Otherwise convert to JSON
+        return json.dumps(data)
+    elif hasattr(data, 'content'):
+        return str(data.content)
+    elif hasattr(data, 'text'):
+        return str(data.text)
+    else:
+        return str(data)
+
+
+def parse_generic_message(message: IntermediateStep) -> dict:
+    """Parse messages that don't fit standard patterns.
+
+    This is a shared utility used by all parser implementations for handling
+    event types that don't have specialized parsers.
+
+    Args:
+        message: An IntermediateStep object representing a message.
+
+    Returns:
+        A dictionary with 'role' and 'content' keys.
+    """
+    result = {"role": "user"}  # Default to user role
+
+    # Try to extract content from various fields
+    if message.data:
+        if message.data.output:
+            result["content"] = extract_content(message.data.output)
+        elif message.data.input:
+            result["content"] = extract_content(message.data.input)
+        elif message.data.chunk:
+            result["content"] = extract_content(message.data.chunk)
+        else:
+            result["content"] = ""
+    else:
+        result["content"] = ""
+
+    return result

nat/finetuning/utils/parsers/langchain_parser.py

@@ -0,0 +1,267 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, 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 langchain_core.messages import AIMessage
+from langchain_core.messages import AIMessageChunk
+from langchain_core.messages import BaseMessage
+from langchain_core.messages import FunctionMessage
+from langchain_core.messages import HumanMessage
+from langchain_core.messages import SystemMessage
+from langchain_core.messages import ToolMessage
+
+from nat.data_models.intermediate_step import IntermediateStep
+from nat.data_models.intermediate_step import IntermediateStepType
+from nat.finetuning.utils.parsers.common import extract_content
+from nat.finetuning.utils.parsers.common import parse_generic_message
+
+# Re-export for backwards compatibility and internal use
+_extract_content = extract_content
+_parse_generic_message = parse_generic_message
+
+
+def parse_to_openai_message(message: IntermediateStep) -> dict | list[dict]:
+    """
+    Convert IntermediateStep to OpenAI-compatible message dictionary.
+
+    Args:
+        message: An IntermediateStep object representing a single message.
+        previous_message: Previous message for context (reserved for future).
+
+    Returns:
+        A dictionary formatted for OpenAI API consumption.
+    """
+
+    # Handle different event types to determine role and extract content
+    if message.event_type == IntermediateStepType.LLM_END:
+        # Assistant message with potential tool calls
+        result = _parse_assistant_message(message)
+    elif message.event_type == IntermediateStepType.TOOL_END:
+        # Tool response message
+        result = _parse_tool_message(message)
+    elif message.event_type == IntermediateStepType.LLM_START:
+        # Extract user/system messages from the input
+        result = _parse_input_message(message)
+        # drop logprobs field if exists
+        if "logprobs" in result:
+            del result["logprobs"]
+    else:
+        # For other types, try to infer from the data
+        result = _parse_generic_message(message)
+
+    return result
+
+
+def _parse_assistant_message(message: IntermediateStep) -> dict:
+    """Parse an assistant message from LLM_END event."""
+    result = {"role": "assistant"}
+    # Get the generation from payload if available
+    if message.data and message.data.payload:
+        payload = message.data.payload
+        msg = None
+        if isinstance(payload, dict) and "message" in payload:
+            # Handle dict payloads
+            try:
+                msg = AIMessage(**payload["message"])
+            except Exception as _:
+                try:
+                    msg = AIMessageChunk(**payload["message"])
+                except Exception as _:
+                    msg = None
+
+        # Handle ChatGeneration objects from LangChain
+        if hasattr(payload, 'message'):
+            msg = payload.message
+        if msg:
+            # Extract content
+            if isinstance(msg, AIMessage):
+                result["content"] = msg.content or ""
+
+                # Extract tool calls if present
+                if hasattr(msg, 'tool_calls') and msg.tool_calls:
+                    result["tool_calls"] = msg.tool_calls
+                elif 'tool_calls' in msg.additional_kwargs:
+                    tool_calls = msg.additional_kwargs['tool_calls']
+                    result["tool_calls"] = tool_calls
+
+                # Extract function call if present
+                if hasattr(msg, 'function_call') and msg.function_call:
+                    result["function_call"] = msg.function_call
+                elif 'function_call' in msg.additional_kwargs:
+                    func_call = msg.additional_kwargs['function_call']
+                    result["function_call"] = func_call
+            else:
+                # Fallback to extracting content as string
+                result["content"] = str(getattr(msg, 'content', msg))
+
+            # Extract logprobs if available
+            gen_info = getattr(msg, 'response_metadata', None)
+            if gen_info and 'logprobs' in gen_info:
+                result["logprobs"] = gen_info['logprobs']
+
+    elif message.data and message.data.output:
+        # Fallback to output field
+        result["content"] = _extract_content(message.data.output)
+    else:
+        result["content"] = ""
+
+    # Check for logprobs in data field
+    logprobs = (getattr(message.data, 'logprobs', None) if message.data else None)
+    if logprobs:
+        result["logprobs"] = logprobs
+
+    # if not logprobs, set to empty dict to avoid issues downstream
+    if "logprobs" not in result:
+        result["logprobs"] = {}
+
+    return result
+
+
+def _parse_tool_message(message: IntermediateStep) -> dict:
+    """Parse a tool response message from TOOL_END event."""
+    result = {"role": "tool"}
+
+    # Extract tool output as content
+    if message.data:
+        if message.data.output:
+            result["content"] = _extract_content(message.data.output)
+        elif message.data.payload:
+            result["content"] = _extract_content(message.data.payload)
+        else:
+            result["content"] = ""
+    else:
+        result["content"] = ""
+
+    # Add tool_call_id if available from metadata or UUID
+    if message.metadata and hasattr(message.metadata, 'tool_call_id'):
+        result["tool_call_id"] = message.metadata.tool_call_id
+    else:
+        result["tool_call_id"] = 0
+
+    return result
+
+
+def _parse_input_message(message: IntermediateStep) -> dict | list[dict]:
+    """Parse user or system messages from LLM_START event."""
+    if not message.data or not message.data.input:
+        return {"role": "user", "content": ""}
+
+    input_data = message.data.input
+
+    # Handle list of messages
+    if isinstance(input_data, list) and len(input_data) > 0:
+        # Get the last message in the list
+        messages = []
+        for msg in input_data:
+            last_msg = msg
+            # Handle BaseMessage objects
+            if isinstance(last_msg, BaseMessage):
+                messages.append(_parse_langchain_message(last_msg))
+            # Handle dict messages
+            elif isinstance(last_msg, dict):
+                messages.append(_parse_dict_message(last_msg))
+            # Handle string messages
+            elif isinstance(last_msg, str):
+                messages.append({"role": "user", "content": last_msg})
+            else:
+                messages.append({"role": "user", "content": str(last_msg)})
+        return messages
+    # Handle single message
+    elif isinstance(input_data, BaseMessage):
+        return _parse_langchain_message(input_data)
+    elif isinstance(input_data, dict):
+        return _parse_dict_message(input_data)
+    else:
+        return {"role": "user", "content": _extract_content(input_data)}
+
+
+def _parse_langchain_message(msg: BaseMessage) -> dict:
+    """Parse a LangChain BaseMessage object."""
+    result = {}
+
+    # Determine role based on message type
+    if isinstance(msg, HumanMessage):
+        result["role"] = "user"
+    elif isinstance(msg, AIMessage):
+        result["role"] = "assistant"
+    elif isinstance(msg, SystemMessage):
+        result["role"] = "system"
+    elif isinstance(msg, ToolMessage):
+        result["role"] = "tool"
+        # Add tool_call_id if present
+        if hasattr(msg, 'tool_call_id'):
+            result["tool_call_id"] = msg.tool_call_id
+    elif isinstance(msg, FunctionMessage):
+        result["role"] = "function"
+        # Add name if present
+        if hasattr(msg, 'name'):
+            result["name"] = msg.name
+    else:
+        # Default to user role for unknown message types
+        result["role"] = "user"
+
+    # Extract content
+    result["content"] = msg.content or ""
+
+    # Handle tool calls for AI messages
+    if isinstance(msg, AIMessage):
+        if hasattr(msg, 'tool_calls') and msg.tool_calls:
+            result["tool_calls"] = msg.tool_calls
+        elif 'tool_calls' in msg.additional_kwargs:
+            result["tool_calls"] = msg.additional_kwargs['tool_calls']
+
+        if hasattr(msg, 'function_call') and msg.function_call:
+            result["function_call"] = msg.function_call
+        elif 'function_call' in msg.additional_kwargs:
+            result["function_call"] = msg.additional_kwargs['function_call']
+
+    return result
+
+
+def _parse_dict_message(msg_dict: dict) -> dict:
+    """Parse a dictionary-based message."""
+    result = {}
+
+    # Extract role
+    #result["role"] = msg_dict.get("role", "user")
+    if "role" in msg_dict:
+        role = msg_dict["role"]
+    elif "type" in msg_dict:
+        role = msg_dict["type"]
+    else:
+        role = "user"
+
+    if role == 'ai':
+        role = 'assistant'
+    elif role == 'human':
+        role = 'user'
+
+    result["role"] = role
+
+    # Extract content
+    if "content" in msg_dict:
+        result["content"] = msg_dict["content"]
+    elif "text" in msg_dict:
+        result["content"] = msg_dict["text"]
+    else:
+        result["content"] = ""
+
+    # Copy over optional fields
+    optional_fields = ["tool_calls", "tool_call_id", "function_call", "name", "logprobs"]
+    for field in optional_fields:
+        if field in msg_dict:
+            result[field] = msg_dict[field]
+
+    return result

nat/finetuning/utils/parsers/llama_index_parser.py

@@ -0,0 +1,218 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, 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 llama_index.core.llms import ChatResponse
+
+from nat.data_models.intermediate_step import IntermediateStep
+from nat.data_models.intermediate_step import IntermediateStepType
+from nat.finetuning.utils.parsers.common import extract_content
+from nat.finetuning.utils.parsers.common import parse_generic_message
+
+# Re-export for backwards compatibility and internal use
+_extract_content = extract_content
+_parse_generic_message = parse_generic_message
+
+
+def parse_to_openai_message(message: IntermediateStep) -> dict:  # noqa: ARG001
+    """
+    Convert IntermediateStep to OpenAI-compatible message dictionary.
+
+    Args:
+        message: An IntermediateStep object representing a single message.
+        previous_message: Previous message for context (reserved for future).
+
+    Returns:
+        A dictionary formatted for OpenAI API consumption.
+    """
+    result = {}
+
+    # Handle different event types to determine role and extract content
+    if message.event_type == IntermediateStepType.LLM_END:
+        # Assistant message from ChatResponse
+        result = _parse_assistant_message(message)
+    elif message.event_type == IntermediateStepType.TOOL_END:
+        # Tool/Function response message
+        result = _parse_tool_message(message)
+    elif message.event_type == IntermediateStepType.LLM_START:
+        # Extract user/system messages from the input
+        result = _parse_input_message(message)
+    else:
+        # For other types, try to infer from the data
+        result = _parse_generic_message(message)
+
+    return result
+
+
+def _parse_assistant_message(message: IntermediateStep) -> dict:
+    """Parse an assistant message from LLM_END event."""
+    result = {"role": "assistant"}
+
+    # Get the ChatResponse from payload if available
+    if message.data and message.data.payload:
+        payload = message.data.payload
+
+        # Handle ChatResponse objects from LlamaIndex
+        if isinstance(payload, ChatResponse):
+            # Extract content from message blocks
+            content = ""
+            msg = getattr(payload, 'message', None)
+            if msg and hasattr(msg, 'blocks'):
+                try:
+                    content = ''.join(block.text for block in msg.blocks)
+                except (AttributeError, TypeError):
+                    # Fallback to str representation
+                    content = str(msg) if msg else ""
+            elif msg:
+                # Direct message content
+                content = str(msg)
+            result["content"] = content
+
+            # Check for tool calls in additional_kwargs
+            if (hasattr(payload, 'message') and hasattr(payload.message, 'additional_kwargs')):
+                additional_kwargs = payload.message.additional_kwargs
+                if 'tool_calls' in additional_kwargs:
+                    result["tool_calls"] = additional_kwargs['tool_calls']
+                if 'function_call' in additional_kwargs:
+                    func_call = additional_kwargs['function_call']
+                    result["function_call"] = func_call
+
+            # Extract logprobs if available
+            raw_attr = getattr(payload, 'raw', None)
+            try:
+                choice = raw_attr.choices[0] if raw_attr and hasattr(raw_attr, 'choices') else None
+                if choice and hasattr(choice, 'logprobs') and choice.logprobs:
+                    result["logprobs"] = choice.logprobs
+            except (AttributeError, IndexError):
+                pass
+
+    elif message.data and message.data.output:
+        # Fallback to output field
+        result["content"] = _extract_content(message.data.output)
+    else:
+        result["content"] = ""
+
+    # if not logprobs, set to empty dict to avoid issues downstream
+    if "logprobs" not in result:
+        result["logprobs"] = {}
+
+    return result
+
+
+def _parse_tool_message(message: IntermediateStep) -> dict:
+    """Parse a tool/function response message from TOOL_END event."""
+    result = {"role": "function"}
+
+    # Extract function output as content
+    if message.data:
+        if message.data.output:
+            result["content"] = _extract_content(message.data.output)
+        elif message.data.payload:
+            result["content"] = _extract_content(message.data.payload)
+        else:
+            result["content"] = ""
+    else:
+        result["content"] = ""
+
+    # Add function name if available
+    if message.name:
+        result["name"] = message.name
+
+    return result
+
+
+def _parse_input_message(message: IntermediateStep) -> dict:
+    """Parse user or system messages from LLM_START event."""
+    if not message.data or not message.data.input:
+        return {"role": "user", "content": ""}
+
+    input_data = message.data.input
+
+    # LlamaIndex typically stores messages as strings in the input
+    if isinstance(input_data, str):
+        # Check if it looks like a system message (heuristic)
+        lower_input = input_data.lower()
+        if (lower_input.startswith("system:") or "system prompt" in lower_input):
+            return {"role": "system", "content": input_data}
+        else:
+            return {"role": "user", "content": input_data}
+
+    # Handle list of messages (from EventPayload.MESSAGES)
+    elif isinstance(input_data, list) and len(input_data) > 0:
+        # Get the last message in the list
+        last_msg = input_data[-1]
+
+        # Try to parse the message
+        if hasattr(last_msg, 'role') and hasattr(last_msg, 'content'):
+            # LlamaIndex ChatMessage object
+            role = str(last_msg.role).lower()
+            # Map LlamaIndex roles to OpenAI roles
+            role_mapping = {
+                'user': 'user',
+                'assistant': 'assistant',
+                'system': 'system',
+                'human': 'user',
+                'ai': 'assistant',
+                'chatbot': 'assistant'
+            }
+            role = role_mapping.get(role, 'user')
+            return {"role": role, "content": str(last_msg.content)}
+        else:
+            # Convert to string if not a message object
+            return {"role": "user", "content": str(last_msg)}
+
+    # Handle dict messages
+    elif isinstance(input_data, dict):
+        return _parse_dict_message(input_data)
+
+    else:
+        return {"role": "user", "content": _extract_content(input_data)}
+
+
+def _parse_dict_message(msg_dict: dict) -> dict:
+    """Parse a dictionary-based message."""
+    result = {}
+
+    # Extract role
+    result["role"] = msg_dict.get("role", "user")
+
+    # Extract content
+    if "content" in msg_dict:
+        result["content"] = msg_dict["content"]
+    elif "text" in msg_dict:
+        result["content"] = msg_dict["text"]
+    elif "blocks" in msg_dict:
+        # Handle LlamaIndex block format
+        blocks = msg_dict["blocks"]
+        if isinstance(blocks, list):
+            content_parts = []
+            for block in blocks:
+                if isinstance(block, dict) and "text" in block:
+                    content_parts.append(block["text"])
+                elif hasattr(block, 'text'):
+                    content_parts.append(block.text)
+            result["content"] = ''.join(content_parts)
+        else:
+            result["content"] = ""
+    else:
+        result["content"] = ""
+
+    # Copy over optional fields
+    optional_fields = ["tool_calls", "function_call", "name", "logprobs"]
+    for field in optional_fields:
+        if field in msg_dict:
+            result[field] = msg_dict[field]
+
+    return result

nat/front_ends/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/front_ends/console/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/front_ends/console/authentication_flow_handler.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/front_ends/console/console_front_end_config.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -30,3 +30,6 @@ class ConsoleFrontEndConfig(FrontEndBaseConfig, name="console"):
                                           description="A single input to submit the the workflow.")
     input_file: Path | None = Field(default=None,
                                     description="Path to a json file of inputs to submit to the workflow.")
+    user_id: str = Field(default="nat_run_user_id",
+                         description="User ID to use for the workflow session. "
+                         "Defaults to 'nat_run_user_id' for single-user CLI execution.")

nat/front_ends/console/console_front_end_plugin.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -70,6 +70,7 @@ class ConsoleFrontEndPlugin(SimpleFrontEndPluginBase[ConsoleFrontEndConfig]):
             async def run_single_query(query):
 
                 async with session_manager.session(
+                        user_id=self.front_end_config.user_id,
                         user_input_callback=prompt_for_input_cli,
                         user_authentication_callback=self.auth_flow_handler.authenticate) as session:
                     async with session.run(query) as runner:
@@ -89,9 +90,9 @@ class ConsoleFrontEndPlugin(SimpleFrontEndPluginBase[ConsoleFrontEndConfig]):
 
             # Run the workflow
             with open(self.front_end_config.input_file, encoding="utf-8") as f:
-
-                async with session_manager.workflow.run(f) as runner:
-                    runner_outputs = await runner.result(to_type=str)
+                async with session_manager.session(user_id=self.front_end_config.user_id) as session:
+                    async with session.run(f) as runner:
+                        runner_outputs = await runner.result(to_type=str)
         else:
             assert False, "Should not reach here. Should have been caught by pre_run"
 

nat/front_ends/console/register.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/front_ends/cron/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/front_ends/fastapi/__init__.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");