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

nat/llm/huggingface_llm.py

@@ -0,0 +1,177 @@
+# 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.
+"""HuggingFace Transformers LLM Provider - Local in-process model execution."""
+
+import logging
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.llm import LLMProviderInfo
+from nat.cli.register_workflow import register_llm_provider
+from nat.data_models.llm import LLMBaseConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelCacheEntry:
+    model: Any
+    tokenizer: Any
+    torch: Any
+
+
+class ModelCache:
+    """Singleton cache for loaded HuggingFace models.
+
+    Models remain cached for the provider's lifetime (not per-query!) to enable fast reuse:
+    - During nat serve: Cached while server runs, cleaned up on shutdown
+    - During nat red-team: Cached across all evaluation queries, cleaned up when complete
+    - During nat run: Cached for single workflow execution, cleaned up when done
+    """
+
+    _instance: "ModelCache | None" = None
+    _cache: dict[str, ModelCacheEntry]
+
+    def __new__(cls) -> "ModelCache":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._cache = {}
+        return cls._instance
+
+    def get(self, model_name: str) -> ModelCacheEntry | None:
+        """Return cached model data or None if not loaded."""
+        return self._cache.get(model_name)
+
+    def set(self, model_name: str, data: ModelCacheEntry) -> None:
+        """Cache model data."""
+        self._cache[model_name] = data
+
+    def remove(self, model_name: str) -> None:
+        """Remove model from cache."""
+        self._cache.pop(model_name, None)
+
+    def __contains__(self, model_name: str) -> bool:
+        """Check if model is cached."""
+        return model_name in self._cache
+
+
+class HuggingFaceConfig(LLMBaseConfig, name="huggingface"):
+    """Configuration for HuggingFace LLM - loads model directly for local execution."""
+
+    model_name: str = Field(description="HuggingFace model name (e.g. 'Qwen/Qwen3Guard-Gen-0.6B')")
+
+    device: str = Field(default="auto", description="Device: 'cpu', 'cuda', 'cuda:0', or 'auto'")
+
+    dtype: str | None = Field(default="auto", description="Torch dtype: 'float16', 'bfloat16', 'float32', or 'auto'")
+
+    max_new_tokens: int = Field(default=128, description="Maximum number of new tokens to generate")
+
+    temperature: float = Field(default=0.0,
+                               description="Sampling temperature (0 = deterministic greedy, > 0 = sampling enabled)")
+
+    trust_remote_code: bool = Field(default=False, description="Trust remote code when loading model")
+
+
+def get_cached_model(model_name: str) -> ModelCacheEntry | None:
+    """Return cached model data (model, tokenizer, torch) or None if not loaded."""
+    return ModelCache().get(model_name)
+
+
+async def _cleanup_model(model_name: str) -> None:
+    """Clean up a loaded model and free GPU memory.
+
+    Args:
+        model_name: Name of the model to clean up.
+    """
+    try:
+        cache = ModelCache()
+        cached = cache.get(model_name)
+
+        if cached is not None:
+            # Move model to CPU to free GPU memory
+            if cached.model:
+                cached.model.to("cpu")
+                cached.model = None
+
+            # Clear CUDA cache if available
+            if cached.torch and hasattr(cached.torch.cuda, "empty_cache"):
+                cached.torch.cuda.empty_cache()
+                cached.torch = None
+
+            cached.tokenizer = None
+
+            # Remove from cache
+            cache.remove(model_name)
+
+            logger.debug("Model cleaned up: %s", model_name)
+    except Exception:
+        logger.exception("Error cleaning up HuggingFace model '%s'", model_name)
+
+
+@register_llm_provider(config_type=HuggingFaceConfig)
+async def huggingface_provider(
+        config: HuggingFaceConfig,
+        builder: Builder,  # noqa: ARG001 - kept for provider interface, currently unused
+) -> AsyncIterator[LLMProviderInfo]:
+    """HuggingFace model provider - loads models locally for in-process execution.
+
+    Args:
+        config: Configuration for the HuggingFace model.
+        builder: The NAT builder instance.
+
+    Yields:
+        LLMProviderInfo: Provider information for the loaded model.
+    """
+    try:
+        import torch
+        from transformers import AutoModelForCausalLM
+        from transformers import AutoTokenizer
+    except ImportError:
+        raise ValueError("HuggingFace dependencies not installed. \n"
+                         "Install with:\n"
+                         "  `pip install nvidia-nat[huggingface]` (package) or\n"
+                         "  `uv pip install -e '.[huggingface]'` (source)\n")
+
+    cache = ModelCache()
+
+    # Load model if not cached
+    if config.model_name not in cache:
+        logger.debug("Loading model from HuggingFace: %s", config.model_name)
+
+        # Load tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(config.model_name, trust_remote_code=config.trust_remote_code)
+
+        # Load model
+        model = AutoModelForCausalLM.from_pretrained(config.model_name,
+                                                     dtype=config.dtype,
+                                                     device_map=config.device,
+                                                     trust_remote_code=config.trust_remote_code)
+
+        # Cache it
+        cache.set(config.model_name, ModelCacheEntry(model=model, tokenizer=tokenizer, torch=torch))
+
+        logger.debug("Model loaded: %s on device: %s", config.model_name, config.device)
+    else:
+        logger.debug("Using cached model: %s", config.model_name)
+
+    try:
+        yield LLMProviderInfo(config=config, description=f"HuggingFace model: {config.model_name}")
+    finally:
+        # Cleanup when workflow/application shuts down
+        await _cleanup_model(config.model_name)

nat/llm/litellm_llm.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/llm/nim_llm.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/llm/openai_llm.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/llm/register.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");
@@ -22,6 +22,8 @@ This module is imported by the NeMo Agent Toolkit runtime to ensure providers ar
 # Import any providers which need to be automatically registered here
 from . import aws_bedrock_llm
 from . import azure_openai_llm
+from . import dynamo_llm
+from . import huggingface_llm
 from . import litellm_llm
 from . import nim_llm
 from . import openai_llm

nat/llm/utils/__init__.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/llm/utils/env_config_value.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/llm/utils/error.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/llm/utils/thinking.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/memory/__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/memory/interfaces.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/memory/models.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/meta/pypi.md

@@ -1,5 +1,5 @@
 <!--
-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/middleware/__init__.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");
@@ -14,7 +14,6 @@
 # limitations under the License.
 """Middleware implementations for NeMo Agent Toolkit."""
 
-from nat.middleware.cache_middleware import CacheMiddleware
 from nat.middleware.function_middleware import FunctionMiddleware
 from nat.middleware.function_middleware import FunctionMiddlewareChain
 from nat.middleware.function_middleware import validate_middleware
@@ -22,14 +21,15 @@ from nat.middleware.middleware import CallNext
 from nat.middleware.middleware import CallNextStream
 from nat.middleware.middleware import FunctionMiddlewareContext
 from nat.middleware.middleware import Middleware
+from nat.middleware.red_teaming.red_teaming_middleware import RedTeamingMiddleware
 
 __all__ = [
-    "CacheMiddleware",
     "CallNext",
     "CallNextStream",
-    "FunctionMiddlewareContext",
-    "Middleware",
     "FunctionMiddleware",
     "FunctionMiddlewareChain",
+    "FunctionMiddlewareContext",
+    "Middleware",
+    "RedTeamingMiddleware",
     "validate_middleware",
 ]

nat/middleware/cache/__init__.py

@@ -0,0 +1,14 @@
+# 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.

nat/middleware/{cache_middleware.py → cache/cache_middleware.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");
@@ -32,17 +32,14 @@ import json
 import logging
 from collections.abc import AsyncIterator
 from typing import Any
-from typing import Literal
-
-from pydantic import Field
 
 from nat.builder.context import Context
 from nat.builder.context import ContextState
-from nat.data_models.middleware import FunctionMiddlewareBaseConfig
 from nat.middleware.function_middleware import CallNext
 from nat.middleware.function_middleware import CallNextStream
 from nat.middleware.function_middleware import FunctionMiddleware
 from nat.middleware.function_middleware import FunctionMiddlewareContext
+from nat.middleware.middleware import InvocationContext
 
 logger = logging.getLogger(__name__)
 
@@ -84,6 +81,23 @@ class CacheMiddleware(FunctionMiddleware):
         self._similarity_threshold = similarity_threshold
         self._cache: dict[str, Any] = {}
 
+    # ==================== Abstract Method Implementations ====================
+
+    @property
+    def enabled(self) -> bool:
+        """Middleware always enabled."""
+        return True
+
+    async def pre_invoke(self, context: InvocationContext) -> InvocationContext | None:  # noqa: ARG002
+        """Not used - CacheMiddleware overrides function_middleware_invoke."""
+        return None
+
+    async def post_invoke(self, context: InvocationContext) -> InvocationContext | None:  # noqa: ARG002
+        """Not used - CacheMiddleware overrides function_middleware_invoke."""
+        return None
+
+    # ==================== Cache Logic ====================
+
     def _should_cache(self) -> bool:
         """Check if caching should be enabled based on the current context."""
         if self._enabled_mode == "always":
@@ -145,8 +159,11 @@ class CacheMiddleware(FunctionMiddleware):
 
         return best_match
 
-    async def function_middleware_invoke(self, value: Any, call_next: CallNext,
-                                         context: FunctionMiddlewareContext) -> Any:
+    async def function_middleware_invoke(self,
+                                         *args: Any,
+                                         call_next: CallNext,
+                                         context: FunctionMiddlewareContext,
+                                         **kwargs: Any) -> Any:
         """Cache middleware for single-output invocations.
 
         Implements the four-phase middleware pattern:
@@ -157,23 +174,27 @@ class CacheMiddleware(FunctionMiddleware):
         4. **Continue**: Return the result (cached or fresh)
 
         Args:
-            value: The input value to process
+            args: The positional arguments to process
             call_next: Callable to invoke the next middleware or function
             context: Metadata about the function being wrapped
+            kwargs: Additional function arguments
 
         Returns:
             The cached output if found, otherwise the fresh output
         """
-        # Phase 1: Preprocess - check if caching should be enabled
+        # Check if caching should be enabled for this invocation
         if not self._should_cache():
-            return await call_next(value)
+            return await call_next(*args, **kwargs)
+
+        # Use first arg as cache key (primary input)
+        value = args[0] if args else None
 
         # Phase 1: Preprocess - serialize the input
         input_str = self._serialize_input(value)
         if input_str is None:
             # Can't serialize, pass through to next middleware/function
             logger.debug("Could not serialize input for function %s, bypassing cache", context.name)
-            return await call_next(value)
+            return await call_next(*args, **kwargs)
 
         # Phase 1: Preprocess - look for a similar cached input
         similar_key = self._find_similar_key(input_str)
@@ -187,7 +208,7 @@ class CacheMiddleware(FunctionMiddleware):
 
         # Phase 2: Call next - no cache hit, call next middleware/function
         logger.debug("Cache miss for function %s", context.name)
-        result = await call_next(value)
+        result = await call_next(*args, **kwargs)
 
         # Phase 3: Postprocess - cache the result for future use
         self._cache[input_str] = result
@@ -197,9 +218,10 @@ class CacheMiddleware(FunctionMiddleware):
         return result
 
     async def function_middleware_stream(self,
-                                         value: Any,
+                                         *args: Any,
                                          call_next: CallNextStream,
-                                         context: FunctionMiddlewareContext) -> AsyncIterator[Any]:
+                                         context: FunctionMiddlewareContext,
+                                         **kwargs: Any) -> AsyncIterator[Any]:
         """Cache middleware for streaming invocations - bypasses caching.
 
         Streaming results are not cached as they would need to be buffered
@@ -213,9 +235,10 @@ class CacheMiddleware(FunctionMiddleware):
         4. **Continue**: Complete the stream
 
         Args:
-            value: The input value to process
+            args: The positional arguments to process
             call_next: Callable to invoke the next middleware or function stream
             context: Metadata about the function being wrapped
+            kwargs: Additional function arguments
 
         Yields:
             Chunks from the stream (unmodified)
@@ -224,33 +247,7 @@ class CacheMiddleware(FunctionMiddleware):
         logger.debug("Streaming call for function %s, bypassing cache", context.name)
 
         # Phase 2-3: Call next and process chunks - yield chunks as they arrive
-        async for chunk in call_next(value):
+        async for chunk in call_next(*args, **kwargs):
             yield chunk
 
         # Phase 4: Continue - stream is complete (implicit)
-
-
-class CacheMiddlewareConfig(FunctionMiddlewareBaseConfig, name="cache"):
-    """Configuration for cache middleware.
-
-    The cache middleware memoizes function outputs based on input similarity,
-    with support for both exact and fuzzy matching.
-
-    Args:
-        enabled_mode: Controls when caching is active:
-            - "always": Cache is always enabled
-            - "eval": Cache only active when Context.is_evaluating is True
-        similarity_threshold: Float between 0 and 1 for input matching:
-            - 1.0: Exact string matching (fastest)
-            - < 1.0: Fuzzy matching using difflib similarity
-    """
-
-    enabled_mode: Literal["always", "eval"] = Field(
-        default="eval", description="When caching is enabled: 'always' or 'eval' (only during evaluation)")
-    similarity_threshold: float = Field(default=1.0,
-                                        ge=0.0,
-                                        le=1.0,
-                                        description="Similarity threshold between 0 and 1. Use 1.0 for exact matching")
-
-
-__all__ = ["CacheMiddleware", "CacheMiddlewareConfig"]

nat/middleware/cache/cache_middleware_config.py

@@ -0,0 +1,44 @@
+# 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.
+"""Configuration for cache middleware."""
+
+from typing import Literal
+
+from pydantic import Field
+
+from nat.data_models.middleware import FunctionMiddlewareBaseConfig
+
+
+class CacheMiddlewareConfig(FunctionMiddlewareBaseConfig, name="cache"):
+    """Configuration for cache middleware.
+
+    The cache middleware memoizes function outputs based on input similarity,
+    with support for both exact and fuzzy matching.
+
+    Args:
+        enabled_mode: Controls when caching is active:
+            - "always": Cache is always enabled
+            - "eval": Cache only active when Context.is_evaluating is True
+        similarity_threshold: Float between 0 and 1 for input matching:
+            - 1.0: Exact string matching (fastest)
+            - < 1.0: Fuzzy matching using difflib similarity
+    """
+
+    enabled_mode: Literal["always", "eval"] = Field(
+        default="eval", description="When caching is enabled: 'always' or 'eval' (only during evaluation)")
+    similarity_threshold: float = Field(default=1.0,
+                                        ge=0.0,
+                                        le=1.0,
+                                        description="Similarity threshold between 0 and 1. Use 1.0 for exact matching")

nat/middleware/cache/register.py

@@ -0,0 +1,33 @@
+# 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 nat.builder.builder import Builder
+from nat.cli.register_workflow import register_middleware
+from nat.middleware.cache.cache_middleware import CacheMiddleware
+from nat.middleware.cache.cache_middleware_config import CacheMiddlewareConfig
+
+
+@register_middleware(config_type=CacheMiddlewareConfig)
+async def cache_middleware(config: CacheMiddlewareConfig, builder: Builder):
+    """Build a cache middleware from configuration.
+
+    Args:
+        config: The cache middleware configuration
+        builder: The workflow builder (unused but required by component pattern)
+
+    Yields:
+        A configured cache middleware instance
+    """
+    yield CacheMiddleware(enabled_mode=config.enabled_mode, similarity_threshold=config.similarity_threshold)

nat/middleware/defense/__init__.py

@@ -0,0 +1,14 @@
+# 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.