nvidia-nat 1.3.0a20250827__py3-none-any.whl → 1.3.0a20250829__py3-none-any.whl

nat/builder/workflow_builder.py

@@ -420,8 +420,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Wrap in the correct wrapper
             return tool_wrapper_reg.build_fn(fn_name, fn.instance, self)
         except Exception as e:
-            logger.error("Error fetching tool `%s`", fn_name, exc_info=True)
-            raise e
+            logger.error("Error fetching tool `%s`: %s", fn_name, e)
+            raise
 
     @override
     async def add_llm(self, name: str | LLMRef, config: LLMBaseConfig):
@@ -436,8 +436,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             self._llms[name] = ConfiguredLLM(config=config, instance=info_obj)
         except Exception as e:
-            logger.error("Error adding llm `%s` with config `%s`", name, config, exc_info=True)
-            raise e
+            logger.error("Error adding llm `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_llm(self, llm_name: str | LLMRef, wrapper_type: LLMFrameworkEnum | str):
@@ -457,8 +457,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting llm `%s` with wrapper `%s`", llm_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting llm `%s` with wrapper `%s`: %s", llm_name, wrapper_type, e)
+            raise
 
     @override
     def get_llm_config(self, llm_name: str | LLMRef) -> LLMBaseConfig:
@@ -508,8 +508,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             return info_obj
         except Exception as e:
-            logger.error("Error adding authentication `%s` with config `%s`", name, config, exc_info=True)
-            raise e
+            logger.error("Error adding authentication `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_auth_provider(self, auth_provider_name: str) -> AuthProviderBase:
@@ -552,9 +552,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             self._embedders[name] = ConfiguredEmbedder(config=config, instance=info_obj)
         except Exception as e:
-            logger.error("Error adding embedder `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding embedder `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_embedder(self, embedder_name: str | EmbedderRef, wrapper_type: LLMFrameworkEnum | str):
@@ -574,8 +573,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting embedder `%s` with wrapper `%s`", embedder_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting embedder `%s` with wrapper `%s`: %s", embedder_name, wrapper_type, e)
+            raise
 
     @override
     def get_embedder_config(self, embedder_name: str | EmbedderRef) -> EmbedderBaseConfig:
@@ -660,9 +659,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             self._retrievers[name] = ConfiguredRetriever(config=config, instance=info_obj)
 
         except Exception as e:
-            logger.error("Error adding retriever `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding retriever `%s` with config `%s`: %s", name, config, e)
+            raise
 
         # return info_obj
 
@@ -687,8 +685,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting retriever `%s` with wrapper `%s`", retriever_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting retriever `%s` with wrapper `%s`: %s", retriever_name, wrapper_type, e)
+            raise
 
     @override
     async def get_retriever_config(self, retriever_name: str | RetrieverRef) -> RetrieverBaseConfig:
@@ -712,9 +710,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             self._ttc_strategies[name] = ConfiguredTTCStrategy(config=config, instance=info_obj)
 
         except Exception as e:
-            logger.error("Error adding TTC strategy `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding TTC strategy `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_ttc_strategy(self,
@@ -742,8 +739,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             return instance
         except Exception as e:
-            logger.error("Error getting TTC strategy `%s`", strategy_name, exc_info=True)
-            raise e
+            logger.error("Error getting TTC strategy `%s`: %s", strategy_name, e)
+            raise
 
     @override
     async def get_ttc_strategy_config(self,
@@ -820,7 +817,7 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         else:
             logger.error("No remaining components to build")
 
-        logger.error("Original error:", exc_info=original_error)
+        logger.error("Original error: %s", original_error, exc_info=True)
 
     def _log_build_failure_component(self,
                                      failing_component: ComponentInstanceData,

nat/cli/cli_utils/config_override.py

@@ -213,7 +213,7 @@ def load_and_override_config(config_file: Path, overrides: tuple[tuple[str, str]
                 yaml.dump(effective_config, default_flow_style=False),
             )
         except Exception as e:
-            logger.exception("Modified configuration failed validation: %s", e, exc_info=True)
+            logger.error("Modified configuration failed validation: %s", e)
             raise click.BadParameter(f"Modified configuration failed validation: {str(e)}")
         finally:
             # Clean up the temporary file

nat/cli/commands/info/list_channels.py

@@ -29,4 +29,4 @@ def list_channels(channel_type: str):
     try:
         settings.print_channel_settings(channel_type=channel_type)
     except Exception as e:
-        logger.exception("Error listing channels: %s", e, exc_info=True)
+        logger.exception("Error listing channels: %s", e)

nat/cli/commands/object_store/__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/cli/commands/object_store/object_store.py

@@ -0,0 +1,227 @@
+# 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 asyncio
+import importlib
+import logging
+import mimetypes
+import time
+from pathlib import Path
+
+import click
+
+from nat.builder.workflow_builder import WorkflowBuilder
+from nat.data_models.object_store import ObjectStoreBaseConfig
+from nat.object_store.interfaces import ObjectStore
+from nat.object_store.models import ObjectStoreItem
+
+logger = logging.getLogger(__name__)
+
+STORE_CONFIGS = {
+    "s3": {
+        "module": "nat.plugins.s3.object_store", "config_class": "S3ObjectStoreClientConfig"
+    },
+    "mysql": {
+        "module": "nat.plugins.mysql.object_store", "config_class": "MySQLObjectStoreClientConfig"
+    },
+    "redis": {
+        "module": "nat.plugins.redis.object_store", "config_class": "RedisObjectStoreClientConfig"
+    }
+}
+
+
+def get_object_store_config(**kwargs) -> ObjectStoreBaseConfig:
+    """Process common object store arguments and return the config class"""
+    store_type = kwargs.pop("store_type")
+    config = STORE_CONFIGS[store_type]
+    module = importlib.import_module(config["module"])
+    config_class = getattr(module, config["config_class"])
+    return config_class(**kwargs)
+
+
+async def upload_file(object_store: ObjectStore, file_path: Path, key: str):
+    """
+    Upload a single file to object store.
+
+    Args:
+        object_store: The object store instance to use.
+        file_path: The path to the file to upload.
+        key: The key to upload the file to.
+    """
+    try:
+        data = await asyncio.to_thread(file_path.read_bytes)
+
+        item = ObjectStoreItem(data=data,
+                               content_type=mimetypes.guess_type(str(file_path))[0],
+                               metadata={
+                                   "original_filename": file_path.name,
+                                   "file_size": str(len(data)),
+                                   "file_extension": file_path.suffix,
+                                   "upload_timestamp": str(int(time.time()))
+                               })
+
+        # Upload using upsert to allow overwriting
+        await object_store.upsert_object(key, item)
+        click.echo(f"✅ Uploaded: {file_path.name} -> {key}")
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to upload {file_path.name}:\n{e}") from e
+
+
+def object_store_command_decorator(async_func):
+    """
+    Decorator that handles the common object store command pattern.
+
+    The decorated function should take (store: ObjectStore, kwargs) as parameters
+    and return an exit code (0 for success).
+    """
+
+    @click.pass_context
+    def wrapper(ctx: click.Context, **kwargs):
+        config = ctx.obj["store_config"]
+
+        async def work():
+            async with WorkflowBuilder() as builder:
+                await builder.add_object_store(name="store", config=config)
+                store = await builder.get_object_store_client("store")
+                return await async_func(store, **kwargs)
+
+        try:
+            exit_code = asyncio.run(work())
+        except Exception as e:
+            raise click.ClickException(f"Command failed: {e}") from e
+        if exit_code != 0:
+            raise click.ClickException(f"Command failed with exit code {exit_code}")
+        return exit_code
+
+    return wrapper
+
+
+@click.command(name="upload", help="Upload a directory to an object store.")
+@click.argument("local_dir",
+                type=click.Path(exists=True, file_okay=False, dir_okay=True, path_type=Path),
+                required=True)
+@click.help_option("--help", "-h")
+@object_store_command_decorator
+async def upload_command(store: ObjectStore, local_dir: Path, **_kwargs):
+    """
+    Upload a directory to an object store.
+
+    Args:
+        local_dir: The local directory to upload.
+        store: The object store to use.
+        _kwargs: Additional keyword arguments.
+    """
+    try:
+        click.echo(f"📁 Processing directory: {local_dir}")
+        file_count = 0
+
+        # Process each file recursively
+        for file_path in local_dir.rglob("*"):
+            if file_path.is_file():
+                key = file_path.relative_to(local_dir).as_posix()
+                await upload_file(store, file_path, key)
+                file_count += 1
+
+        click.echo(f"✅ Directory uploaded successfully! {file_count} files uploaded.")
+        return 0
+
+    except Exception as e:
+        raise click.ClickException(f"❌ Failed to upload directory {local_dir}:\n  {e}") from e
+
+
+@click.command(name="delete", help="Delete files from an object store.")
+@click.argument("keys", type=str, required=True, nargs=-1)
+@click.help_option("--help", "-h")
+@object_store_command_decorator
+async def delete_command(store: ObjectStore, keys: list[str], **_kwargs):
+    """
+    Delete files from an object store.
+
+    Args:
+        store: The object store to use.
+        keys: The keys to delete.
+        _kwargs: Additional keyword arguments.
+    """
+    deleted_count = 0
+    failed_count = 0
+    for key in keys:
+        try:
+            await store.delete_object(key)
+            click.echo(f"✅ Deleted: {key}")
+            deleted_count += 1
+        except Exception as e:
+            click.echo(f"❌ Failed to delete {key}: {e}")
+            failed_count += 1
+
+    click.echo(f"✅ Deletion completed! {deleted_count} keys deleted. {failed_count} keys failed to delete.")
+    return 0 if failed_count == 0 else 1
+
+
+@click.group(name="object-store", invoke_without_command=False, help="Manage object store operations.")
+def object_store_command(**_kwargs):
+    """Manage object store operations including uploading files and directories."""
+    pass
+
+
+def register_object_store_commands():
+
+    @click.group(name="s3", invoke_without_command=False, help="S3 object store operations.")
+    @click.argument("bucket_name", type=str, required=True)
+    @click.option("--endpoint-url", type=str, help="S3 endpoint URL")
+    @click.option("--access-key", type=str, help="S3 access key")
+    @click.option("--secret-key", type=str, help="S3 secret key")
+    @click.option("--region", type=str, help="S3 region")
+    @click.pass_context
+    def s3(ctx: click.Context, **kwargs):
+        ctx.ensure_object(dict)
+        ctx.obj["store_config"] = get_object_store_config(store_type="s3", **kwargs)
+
+    @click.group(name="mysql", invoke_without_command=False, help="MySQL object store operations.")
+    @click.argument("bucket_name", type=str, required=True)
+    @click.option("--host", type=str, help="MySQL host")
+    @click.option("--port", type=int, help="MySQL port")
+    @click.option("--db", type=str, help="MySQL database name")
+    @click.option("--username", type=str, help="MySQL username")
+    @click.option("--password", type=str, help="MySQL password")
+    @click.pass_context
+    def mysql(ctx: click.Context, **kwargs):
+        ctx.ensure_object(dict)
+        ctx.obj["store_config"] = get_object_store_config(store_type="mysql", **kwargs)
+
+    @click.group(name="redis", invoke_without_command=False, help="Redis object store operations.")
+    @click.argument("bucket_name", type=str, required=True)
+    @click.option("--host", type=str, help="Redis host")
+    @click.option("--port", type=int, help="Redis port")
+    @click.option("--db", type=int, help="Redis db")
+    @click.pass_context
+    def redis(ctx: click.Context, **kwargs):
+        ctx.ensure_object(dict)
+        ctx.obj["store_config"] = get_object_store_config(store_type="redis", **kwargs)
+
+    commands = {"s3": s3, "mysql": mysql, "redis": redis}
+
+    for store_type, config in STORE_CONFIGS.items():
+        try:
+            importlib.import_module(config["module"])
+            command = commands[store_type]
+            object_store_command.add_command(command, name=store_type)
+            command.add_command(upload_command, name="upload")
+            command.add_command(delete_command, name="delete")
+        except ImportError:
+            pass
+
+
+register_object_store_commands()

nat/cli/commands/registry/publish.py

@@ -40,7 +40,7 @@ async def publish_artifact(registry_handler_config: RegistryHandlerBaseConfig, p
         try:
             artifact = build_artifact(package_root=package_root)
         except Exception as e:
-            logger.exception("Error building artifact: %s", e, exc_info=True)
+            logger.exception("Error building artifact: %s", e)
             return
         await stack.enter_async_context(registry_handler.publish(artifact=artifact))
 
@@ -82,7 +82,7 @@ def publish(channel: str, config_file: str, package_root: str) -> None:
             logger.error("Publish channel '%s' has not been configured.", channel)
             return
     except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
+        logger.exception("Error loading user settings: %s", e)
         return
 
     asyncio.run(publish_artifact(registry_handler_config=publish_channel_config, package_root=package_root))

nat/cli/commands/registry/pull.py

@@ -66,7 +66,7 @@ async def pull_artifact(registry_handler_config: RegistryHandlerBaseConfig, pack
             validated_packages = PullRequestPackages(packages=package_list)
 
         except Exception as e:
-            logger.exception("Error processing package names: %s", e, exc_info=True)
+            logger.exception("Error processing package names: %s", e)
             return
 
         await stack.enter_async_context(registry_handler.pull(packages=validated_packages))
@@ -112,7 +112,7 @@ def pull(channel: str, config_file: str, packages: str) -> None:
             logger.error("Pull channel '%s' has not been configured.", channel)
             return
     except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
+        logger.exception("Error loading user settings: %s", e)
         return
 
     asyncio.run(pull_artifact(pull_channel_config, packages))

nat/cli/commands/registry/remove.py

@@ -41,7 +41,7 @@ async def remove_artifact(registry_handler_config: RegistryHandlerBaseConfig, pa
         try:
             package_name_list = PackageNameVersionList(**{"packages": packages})
         except Exception as e:
-            logger.exception("Invalid package format: '%s'", e, exc_info=True)
+            logger.exception("Invalid package format: '%s'", e)
 
         await stack.enter_async_context(registry_handler.remove(packages=package_name_list))
 
@@ -102,7 +102,7 @@ def remove(channel: str, config_file: str, packages: str) -> None:
             logger.error("Remove channel '%s' has not been configured.", channel)
             return
     except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
+        logger.exception("Error loading user settings: %s", e)
         return
 
     asyncio.run(remove_artifact(registry_handler_config=remove_channel_config, packages=packages_versions))

nat/cli/commands/registry/search.py

@@ -140,7 +140,7 @@ def search(config_file: str,
             logger.error("Search channel '%s' has not been configured.", channel)
             return
     except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
+        logger.exception("Error loading user settings: %s", e)
         return
 
     asyncio.run(

nat/cli/commands/start.py

@@ -224,7 +224,7 @@ class StartCommandGroup(click.Group):
             return asyncio.run(run_plugin())
 
         except Exception as e:
-            logger.error("Failed to initialize workflow", exc_info=True)
+            logger.error("Failed to initialize workflow")
             raise click.ClickException(str(e)) from e
 
     def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:

nat/cli/commands/uninstall.py

@@ -44,7 +44,7 @@ async def uninstall_packages(packages: list[dict[str, str]]) -> None:
     try:
         package_name_list = PackageNameVersionList(**{"packages": packages})
     except Exception as e:
-        logger.exception("Error validating package format: %s", e, exc_info=True)
+        logger.exception("Error validating package format: %s", e)
         return
 
     async with AsyncExitStack() as stack:

nat/cli/commands/workflow/workflow_commands.py

@@ -97,7 +97,7 @@ def find_package_root(package_name: str) -> Path | None:
         try:
             info = json.loads(direct_url)
         except json.JSONDecodeError:
-            logger.error("Malformed direct_url.json for package: %s", package_name)
+            logger.exception("Malformed direct_url.json for package: %s", package_name)
             return None
 
         if not info.get("dir_info", {}).get("editable"):
@@ -271,7 +271,7 @@ def create_command(workflow_name: str, install: bool, workflow_dir: str, descrip
 
         click.echo(f"Workflow '{workflow_name}' created successfully in '{new_workflow_dir}'.")
     except Exception as e:
-        logger.exception("An error occurred while creating the workflow: %s", e, exc_info=True)
+        logger.exception("An error occurred while creating the workflow: %s", e)
         click.echo(f"An error occurred while creating the workflow: {e}")
 
 
@@ -307,7 +307,7 @@ def reinstall_command(workflow_name):
 
         click.echo(f"Workflow '{workflow_name}' reinstalled successfully.")
     except Exception as e:
-        logger.exception("An error occurred while reinstalling the workflow: %s", e, exc_info=True)
+        logger.exception("An error occurred while reinstalling the workflow: %s", e)
         click.echo(f"An error occurred while reinstalling the workflow: {e}")
 
 
@@ -354,7 +354,7 @@ def delete_command(workflow_name: str):
 
         click.echo(f"Workflow '{workflow_name}' deleted successfully.")
     except Exception as e:
-        logger.exception("An error occurred while deleting the workflow: %s", e, exc_info=True)
+        logger.exception("An error occurred while deleting the workflow: %s", e)
         click.echo(f"An error occurred while deleting the workflow: {e}")
 
 

nat/cli/entrypoint.py

@@ -33,6 +33,7 @@ import nest_asyncio
 from .commands.configure.configure import configure_command
 from .commands.evaluate import eval_command
 from .commands.info.info import info_command
+from .commands.object_store.object_store import object_store_command
 from .commands.registry.registry import registry_command
 from .commands.sizing.sizing import sizing
 from .commands.start import start_command
@@ -107,11 +108,12 @@ cli.add_command(uninstall_command, name="uninstall")
 cli.add_command(validate_command, name="validate")
 cli.add_command(workflow_command, name="workflow")
 cli.add_command(sizing, name="sizing")
+cli.add_command(object_store_command, name="object-store")
 
 # Aliases
 cli.add_command(start_command.get_command(None, "console"), name="run")  # type: ignore
 cli.add_command(start_command.get_command(None, "fastapi"), name="serve")  # type: ignore
-cli.add_command(start_command.get_command(None, "mcp"), name="mcp")
+cli.add_command(start_command.get_command(None, "mcp"), name="mcp")  # type: ignore
 
 
 @cli.result_callback()

nat/data_models/discovery_metadata.py

@@ -177,7 +177,7 @@ class DiscoveryMetadata(BaseModel):
                 logger.warning("Package metadata not found for %s", distro_name)
                 version = ""
         except Exception as e:
-            logger.exception("Encountered issue extracting module metadata for %s: %s", config_type, e, exc_info=True)
+            logger.exception("Encountered issue extracting module metadata for %s: %s", config_type, e)
             return DiscoveryMetadata(status=DiscoveryStatusEnum.FAILURE)
 
         description = generate_config_type_docs(config_type=config_type)
@@ -217,7 +217,7 @@ class DiscoveryMetadata(BaseModel):
                 logger.warning("Package metadata not found for %s", distro_name)
                 version = ""
         except Exception as e:
-            logger.exception("Encountered issue extracting module metadata for %s: %s", fn, e, exc_info=True)
+            logger.exception("Encountered issue extracting module metadata for %s: %s", fn, e)
             return DiscoveryMetadata(status=DiscoveryStatusEnum.FAILURE)
 
         if isinstance(wrapper_type, LLMFrameworkEnum):
@@ -252,7 +252,7 @@ class DiscoveryMetadata(BaseModel):
                 description = ""
                 package_version = package_version or ""
         except Exception as e:
-            logger.exception("Encountered issue extracting module metadata for %s: %s", package_name, e, exc_info=True)
+            logger.exception("Encountered issue extracting module metadata for %s: %s", package_name, e)
             return DiscoveryMetadata(status=DiscoveryStatusEnum.FAILURE)
 
         return DiscoveryMetadata(package=package_name,
@@ -290,7 +290,7 @@ class DiscoveryMetadata(BaseModel):
                 logger.warning("Package metadata not found for %s", distro_name)
                 version = ""
         except Exception as e:
-            logger.exception("Encountered issue extracting module metadata for %s: %s", config_type, e, exc_info=True)
+            logger.exception("Encountered issue extracting module metadata for %s: %s", config_type, e)
             return DiscoveryMetadata(status=DiscoveryStatusEnum.FAILURE)
 
         wrapper_type = wrapper_type.value if isinstance(wrapper_type, LLMFrameworkEnum) else wrapper_type

nat/data_models/gated_field_mixin.py

@@ -16,8 +16,6 @@
 from collections.abc import Sequence
 from dataclasses import dataclass
 from re import Pattern
-from typing import Generic
-from typing import TypeVar
 
 from pydantic import model_validator
 
@@ -33,10 +31,7 @@ class GatedFieldMixinConfig:
     keys: Sequence[str]
 
 
-T = TypeVar("T")
-
-
-class GatedFieldMixin(Generic[T]):
+class GatedFieldMixin:
     """
     A mixin that gates a field based on specified keys.
 
@@ -46,7 +41,7 @@ class GatedFieldMixin(Generic[T]):
     ----------
     field_name: `str`
                 The name of the field.
-    default_if_supported: `T | None`
+    default_if_supported: `object | None`
                           The default value of the field if it is supported for the key.
     keys: `Sequence[str]`
           A sequence of keys that are used to validate the field.
@@ -61,7 +56,7 @@ class GatedFieldMixin(Generic[T]):
     def __init_subclass__(
         cls,
         field_name: str | None = None,
-        default_if_supported: T | None = None,
+        default_if_supported: object | None = None,
         keys: Sequence[str] | None = None,
         unsupported: Sequence[Pattern[str]] | None = None,
         supported: Sequence[Pattern[str]] | None = None,
@@ -90,7 +85,7 @@ class GatedFieldMixin(Generic[T]):
     def _setup_direct_mixin(
         cls,
         field_name: str,
-        default_if_supported: T | None,
+        default_if_supported: object | None,
         unsupported: Sequence[Pattern[str]] | None,
         supported: Sequence[Pattern[str]] | None,
         keys: Sequence[str],
@@ -135,7 +130,7 @@ class GatedFieldMixin(Generic[T]):
     def _create_gated_field_validator(
         cls,
         field_name: str,
-        default_if_supported: T | None,
+        default_if_supported: object | None,
         unsupported: Sequence[Pattern[str]] | None,
         supported: Sequence[Pattern[str]] | None,
         keys: Sequence[str],
@@ -167,16 +162,19 @@ class GatedFieldMixin(Generic[T]):
         keys: Sequence[str],
     ) -> bool:
         """Check if a specific field is supported based on its configuration and keys."""
+        seen = False
         for key in keys:
             if not hasattr(instance, key):
                 continue
+            seen = True
             value = str(getattr(instance, key))
             if supported is not None:
-                return any(p.search(value) for p in supported)
+                if any(p.search(value) for p in supported):
+                    return True
             elif unsupported is not None:
-                return not any(p.search(value) for p in unsupported)
-        # Default to supported if no model keys found
-        return True
+                if any(p.search(value) for p in unsupported):
+                    return False
+        return True if not seen else (unsupported is not None)
 
     @classmethod
     def _find_blocking_key(

nat/data_models/temperature_mixin.py

@@ -23,7 +23,7 @@ from nat.data_models.gated_field_mixin import GatedFieldMixin
 
 class TemperatureMixin(
         BaseModel,
-        GatedFieldMixin[float],
+        GatedFieldMixin,
         field_name="temperature",
         default_if_supported=0.0,
         keys=("model_name", "model", "azure_deployment"),