nvidia-nat 1.3.0a20250822__py3-none-any.whl → 1.3.0a20250823__py3-none-any.whl

aiq/__init__.py

@@ -13,10 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import sys
 import importlib
 import importlib.abc
 import importlib.util
+import sys
 import warnings
 
 
@@ -26,7 +26,7 @@ class CompatFinder(importlib.abc.MetaPathFinder):
         self.alias_prefix = alias_prefix
         self.target_prefix = target_prefix
 
-    def find_spec(self, fullname, path, target=None):  # pylint: disable=unused-argument
+    def find_spec(self, fullname, path, target=None):
         if fullname == self.alias_prefix or fullname.startswith(self.alias_prefix + "."):
             # Map aiq.something -> nat.something
             target_name = self.target_prefix + fullname[len(self.alias_prefix):]

nat/agent/base.py

@@ -179,7 +179,6 @@ class BaseAgent(ABC):
                 logger.debug("%s Retrying tool call for %s in %d seconds...", AGENT_LOG_PREFIX, tool.name, sleep_time)
                 await asyncio.sleep(sleep_time)
 
-        # pylint: disable=C0209
         # All retries exhausted, return error message
         error_content = "Tool call failed after all retry attempts. Last error: %s" % str(last_exception)
         logger.error("%s %s", AGENT_LOG_PREFIX, error_content)

nat/agent/react_agent/agent.py

@@ -14,8 +14,8 @@
 # limitations under the License.
 
 import json
-# pylint: disable=R0917
 import logging
+import re
 import typing
 from json import JSONDecodeError
 
@@ -23,12 +23,14 @@ from langchain_core.agents import AgentAction
 from langchain_core.agents import AgentFinish
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.language_models import BaseChatModel
+from langchain_core.language_models import LanguageModelInput
 from langchain_core.messages.ai import AIMessage
 from langchain_core.messages.base import BaseMessage
 from langchain_core.messages.human import HumanMessage
 from langchain_core.messages.tool import ToolMessage
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.prompts import MessagesPlaceholder
+from langchain_core.runnables import Runnable
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
@@ -97,11 +99,27 @@ class ReActAgentGraph(DualNodeAgent):
                          f"{INPUT_SCHEMA_MESSAGE.format(schema=tools[-1].input_schema.model_fields)}")
         prompt = prompt.partial(tools=tool_names_and_descriptions, tool_names=tool_names)
         # construct the ReAct Agent
-        bound_llm = llm.bind(stop=["Observation:"])  # type: ignore
-        self.agent = prompt | bound_llm
+        self.agent = prompt | self._maybe_bind_llm_and_yield()
         self.tools_dict = {tool.name: tool for tool in tools}
         logger.debug("%s Initialized ReAct Agent Graph", AGENT_LOG_PREFIX)
 
+    def _maybe_bind_llm_and_yield(self) -> Runnable[LanguageModelInput, BaseMessage]:
+        """
+        Bind additional parameters to the LLM if needed
+        - if the LLM is a smart model, no need to bind any additional parameters
+        - if the LLM is a non-smart model, bind a stop sequence to the LLM
+
+        Returns:
+            Runnable[LanguageModelInput, BaseMessage]: The LLM with any additional parameters bound.
+        """
+        # models that don't need (or don't support)a stop sequence
+        smart_models = re.compile(r"gpt-?5", re.IGNORECASE)
+        if any(smart_models.search(getattr(self.llm, model, "")) for model in ["model", "model_name"]):
+            # no need to bind any additional parameters to the LLM
+            return self.llm
+        # add a stop sequence to the LLM
+        return self.llm.bind(stop=["Observation:"])
+
     def _get_tool(self, tool_name: str):
         try:
             return self.tools_dict.get(tool_name)

nat/agent/react_agent/register.py

@@ -125,7 +125,7 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
 
             # get and return the output from the state
             state = ReActGraphState(**state)
-            output_message = state.messages[-1]  # pylint: disable=E1136
+            output_message = state.messages[-1]
             return ChatResponse.from_string(str(output_message.content))
 
         except Exception as ex:

nat/agent/register.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=unused-import
 # flake8: noqa
 
 # Import any workflows which need to be automatically registered here

nat/agent/rewoo_agent/agent.py

@@ -14,7 +14,6 @@
 # limitations under the License.
 
 import json
-# pylint: disable=R0917
 import logging
 from json import JSONDecodeError
 

nat/agent/rewoo_agent/register.py

@@ -133,7 +133,7 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
 
             # get and return the output from the state
             state = ReWOOGraphState(**state)
-            output_message = state.result.content  # pylint: disable=E1101
+            output_message = state.result.content
             return ChatResponse.from_string(output_message)
 
         except Exception as ex:

nat/agent/tool_calling_agent/agent.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=R0917
 import logging
 import typing
 

nat/agent/tool_calling_agent/register.py

@@ -86,7 +86,7 @@ async def tool_calling_agent_workflow(config: ToolCallAgentWorkflowConfig, build
 
             # get and return the output from the state
             state = ToolCallAgentGraphState(**state)
-            output_message = state.messages[-1]  # pylint: disable=E1136
+            output_message = state.messages[-1]
             return output_message.content
         except Exception as ex:
             logger.exception("%s Tool Calling Agent failed with exception: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)

nat/authentication/api_key/api_key_auth_provider.py

@@ -31,7 +31,7 @@ class APIKeyAuthProvider(AuthProviderBase[APIKeyAuthProviderConfig]):
     # fmt: off
     def __init__(self,
                  config: APIKeyAuthProviderConfig,
-                 config_name: str | None = None) -> None:  # pylint: disable=unused-argument
+                 config_name: str | None = None) -> None:
         assert isinstance(config, APIKeyAuthProviderConfig), ("Config is not APIKeyAuthProviderConfig")
         super().__init__(config)
     # fmt: on

nat/authentication/register.py

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=unused-import
 # flake8: noqa
 
 from nat.authentication.api_key import register as register_api_key

nat/builder/builder.py

@@ -58,7 +58,7 @@ class UserManagerHolder():
         return self._context.user_manager.get_id()
 
 
-class Builder(ABC):  # pylint: disable=too-many-public-methods
+class Builder(ABC):
 
     @abstractmethod
     async def add_function(self, name: str | FunctionRef, config: FunctionBaseConfig) -> Function:

nat/builder/context.py

@@ -38,7 +38,7 @@ from nat.utils.reactive.subject import Subject
 
 class Singleton(type):
 
-    def __init__(cls, name, bases, dict):  # pylint: disable=W0622
+    def __init__(cls, name, bases, dict):
         super(Singleton, cls).__init__(name, bases, dict)
         cls.instance = None
 
@@ -65,6 +65,7 @@ class ContextState(metaclass=Singleton):
 
     def __init__(self):
         self.conversation_id: ContextVar[str | None] = ContextVar("conversation_id", default=None)
+        self.user_message_id: ContextVar[str | None] = ContextVar("user_message_id", default=None)
         self.input_message: ContextVar[typing.Any] = ContextVar("input_message", default=None)
         self.user_manager: ContextVar[typing.Any] = ContextVar("user_manager", default=None)
         self.metadata: ContextVar[RequestAttributes] = ContextVar("request_attributes", default=RequestAttributes())
@@ -165,6 +166,13 @@ class Context:
         """
         return self._context_state.conversation_id.get()
 
+    @property
+    def user_message_id(self) -> str | None:
+        """
+        This property retrieves the user message ID which is the unique identifier for the current user message.
+        """
+        return self._context_state.user_message_id.get()
+
     @contextmanager
     def push_active_function(self, function_name: str, input_data: typing.Any | None):
         """

nat/builder/function_base.py

@@ -111,7 +111,7 @@ class FunctionBase(typing.Generic[InputT, StreamingOutputT, SingleOutputT], ABC)
         ValueError
             If the input type cannot be determined from the class definition
         """
-        for base_cls in self.__class__.__orig_bases__:  # pylint: disable=no-member # type: ignore
+        for base_cls in self.__class__.__orig_bases__:
 
             base_cls_args = typing.get_args(base_cls)
 
@@ -196,7 +196,7 @@ class FunctionBase(typing.Generic[InputT, StreamingOutputT, SingleOutputT], ABC)
         ValueError
             If the streaming output type cannot be determined from the class definition
         """
-        for base_cls in self.__class__.__orig_bases__:  # pylint: disable=no-member # type: ignore
+        for base_cls in self.__class__.__orig_bases__:
 
             base_cls_args = typing.get_args(base_cls)
 
@@ -269,7 +269,7 @@ class FunctionBase(typing.Generic[InputT, StreamingOutputT, SingleOutputT], ABC)
         ValueError
             If the single output type cannot be determined from the class definition
         """
-        for base_cls in self.__class__.__orig_bases__:  # pylint: disable=no-member # type: ignore
+        for base_cls in self.__class__.__orig_bases__:
 
             base_cls_args = typing.get_args(base_cls)
 

nat/builder/function_info.py

@@ -231,7 +231,7 @@ class FunctionDescriptor:
         else:
             annotations = [param.annotation for param in sig.parameters.values()]
 
-            is_input_typed = all([a != sig.empty for a in annotations])  # pylint: disable=use-a-generator
+            is_input_typed = all([a != sig.empty for a in annotations])
 
             input_type = tuple[*annotations] if is_input_typed else None  # noqa: syntax-error
 
@@ -372,18 +372,16 @@ class FunctionInfo:
 
             if (stream_to_single_fn is not None):
                 raise ValueError("Cannot provide both single_fn and stream_to_single_fn")
-        else:
-            if (stream_to_single_fn is not None and stream_fn is None):
-                raise ValueError("stream_fn must be provided if stream_to_single_fn is provided")
+        elif (stream_to_single_fn is not None and stream_fn is None):
+            raise ValueError("stream_fn must be provided if stream_to_single_fn is provided")
 
         if (stream_fn is not None):
             final_stream_fn = stream_fn
 
             if (single_to_stream_fn is not None):
                 raise ValueError("Cannot provide both stream_fn and single_to_stream_fn")
-        else:
-            if (single_to_stream_fn is not None and single_fn is None):
-                raise ValueError("single_fn must be provided if single_to_stream_fn is provided")
+        elif (single_to_stream_fn is not None and single_fn is None):
+            raise ValueError("single_fn must be provided if single_to_stream_fn is provided")
 
         if (single_fn is None and stream_fn is None):
             raise ValueError("At least one of single_fn or stream_fn must be provided")

nat/builder/workflow_builder.py

@@ -127,7 +127,6 @@ class ConfiguredTTCStrategy:
     instance: StrategyBase
 
 
-# pylint: disable=too-many-public-methods
 class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
     def __init__(self, *, general_config: GeneralConfig | None = None, registry: TypeRegistry | None = None):

nat/cli/commands/evaluate.py

@@ -97,7 +97,7 @@ async def run_and_evaluate(config: EvaluationRunConfig):
 
 @eval_command.result_callback(replace=True)
 def process_nat_eval(
-    processors,  # pylint: disable=unused-argument
+    processors,
     *,
     config_file: Path,
     dataset: Path,

nat/cli/commands/info/list_components.py

@@ -26,14 +26,13 @@ from nat.registry_handlers.schemas.search import SearchFields
 logger = logging.getLogger(__name__)
 
 
-async def search_artifacts(  # pylint: disable=R0917
-        registry_handler_config: RegistryHandlerBaseConfig,
-        component_types: list[ComponentEnum],
-        visualize: bool,
-        query: str,
-        num_results: int,
-        query_fields: list[SearchFields],
-        save_path: str | None) -> None:
+async def search_artifacts(registry_handler_config: RegistryHandlerBaseConfig,
+                           component_types: list[ComponentEnum],
+                           visualize: bool,
+                           query: str,
+                           num_results: int,
+                           query_fields: list[SearchFields],
+                           save_path: str | None) -> None:
 
     from nat.cli.type_registry import GlobalTypeRegistry
     from nat.registry_handlers.schemas.search import SearchQuery

nat/cli/commands/info/list_mcp.py

@@ -297,8 +297,7 @@ def ping(url: str, timeout: int, json_output: bool) -> None:
 
     if json_output:
         click.echo(result.model_dump_json(indent=2))
+    elif result.status == "healthy":
+        click.echo(f"Server at {result.url} is healthy (response time: {result.response_time_ms}ms)")
     else:
-        if result.status == "healthy":
-            click.echo(f"Server at {result.url} is healthy (response time: {result.response_time_ms}ms)")
-        else:
-            click.echo(f"Server at {result.url} {result.status}: {result.error}")
+        click.echo(f"Server at {result.url} {result.status}: {result.error}")

nat/cli/commands/registry/search.py

@@ -29,14 +29,13 @@ from nat.utils.data_models.schema_validator import validate_yaml
 logger = logging.getLogger(__name__)
 
 
-async def search_artifacts(  # pylint: disable=R0917
-        registry_handler_config: RegistryHandlerBaseConfig,
-        query: str,
-        search_fields: list[SearchFields],
-        visualize: bool,
-        component_types: list[ComponentEnum],
-        save_path: str | None = None,
-        n_results: int = 10) -> None:
+async def search_artifacts(registry_handler_config: RegistryHandlerBaseConfig,
+                           query: str,
+                           search_fields: list[SearchFields],
+                           visualize: bool,
+                           component_types: list[ComponentEnum],
+                           save_path: str | None = None,
+                           n_results: int = 10) -> None:
 
     from nat.cli.type_registry import GlobalTypeRegistry
     from nat.registry_handlers.schemas.search import SearchQuery
@@ -116,14 +115,13 @@ async def search_artifacts(  # pylint: disable=R0917
     required=False,
     help=("The component types to include in search."),
 )
-def search(  # pylint: disable=R0917
-        config_file: str,
-        channel: str,
-        fields: list[str],
-        query: str,
-        component_types: list[ComponentEnum],
-        n_results: int,
-        output_path: str) -> None:
+def search(config_file: str,
+           channel: str,
+           fields: list[str],
+           query: str,
+           component_types: list[ComponentEnum],
+           n_results: int,
+           output_path: str) -> None:
     """
     Search for NAT artifacts with the specified configuration.
     """

nat/cli/commands/start.py

@@ -35,7 +35,6 @@ logger = logging.getLogger(__name__)
 
 class StartCommandGroup(click.Group):
 
-    # pylint: disable=too-many-positional-arguments
     def __init__(
         self,
         name: str | None = None,

nat/cli/commands/workflow/templates/register.py.j2

@@ -1,4 +1,3 @@
-# pylint: disable=unused-import
 # flake8: noqa
 
 # Import any tools which need to be automatically registered here

nat/cli/commands/workflow/workflow_commands.py

@@ -161,7 +161,6 @@ def get_workflow_path_from_name(workflow_name: str):
     default="NAT function template. Please update the description.",
     help="""A description of the component being created. Will be used to populate the docstring and will describe the
          component when inspecting installed components using 'nat info component'""")
-# pylint: disable=missing-param-doc
 def create_command(workflow_name: str, install: bool, workflow_dir: str, description: str):
     """
     Create a new NAT workflow using templates.

nat/cli/type_registry.py

@@ -298,7 +298,7 @@ class RegisteredPackage(BaseModel):
     discovery_metadata: DiscoveryMetadata
 
 
-class TypeRegistry:  # pylint: disable=too-many-public-methods
+class TypeRegistry:
 
     def __init__(self) -> None:
         # Telemetry Exporters
@@ -779,7 +779,7 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
 
         self._registration_changed()
 
-    def get_infos_by_type(self, component_type: ComponentEnum) -> dict:  # pylint: disable=R0911
+    def get_infos_by_type(self, component_type: ComponentEnum) -> dict:
 
         if component_type == ComponentEnum.FRONT_END:
             return self._registered_front_end_infos
@@ -849,8 +849,7 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
 
         raise ValueError(f"Supplied an unsupported component type {component_type}")
 
-    def get_registered_types_by_component_type(  # pylint: disable=R0911
-            self, component_type: ComponentEnum) -> list[str]:
+    def get_registered_types_by_component_type(self, component_type: ComponentEnum) -> list[str]:
 
         if component_type == ComponentEnum.FUNCTION:
             return [i.static_type() for i in self._registered_functions]
@@ -925,7 +924,6 @@ class TypeRegistry:  # pylint: disable=too-many-public-methods
             if (short_names[key.local_name] == 1):
                 type_list.append((key.local_name, key.config_type))
 
-        # pylint: disable=consider-alternative-union-syntax
         return typing.Union[tuple(typing.Annotated[x_type, Tag(x_id)] for x_id, x_type in type_list)]
 
     def compute_annotation(self, cls: type[TypedBaseModelT]):

nat/data_models/config.py

@@ -47,7 +47,7 @@ logger = logging.getLogger(__name__)
 
 
 def _process_validation_error(err: ValidationError, handler: ValidatorFunctionWrapHandler, info: ValidationInfo):
-    from nat.cli.type_registry import GlobalTypeRegistry  # pylint: disable=cyclic-import
+    from nat.cli.type_registry import GlobalTypeRegistry
 
     new_errors = []
     logged_once = False

nat/data_models/evaluate.py

@@ -108,7 +108,7 @@ class EvalConfig(BaseModel):
     @classmethod
     def rebuild_annotations(cls):
 
-        from nat.cli.type_registry import GlobalTypeRegistry  # pylint: disable=cyclic-import
+        from nat.cli.type_registry import GlobalTypeRegistry
 
         type_registry = GlobalTypeRegistry.get()
 

nat/data_models/function_dependencies.py

@@ -54,19 +54,19 @@ class FunctionDependencies(BaseModel):
         return list(v)
 
     def add_function(self, function: str):
-        self.functions.add(function)  # pylint: disable=no-member
+        self.functions.add(function)
 
     def add_llm(self, llm: str):
-        self.llms.add(llm)  # pylint: disable=no-member
+        self.llms.add(llm)
 
     def add_embedder(self, embedder: str):
-        self.embedders.add(embedder)  # pylint: disable=no-member
+        self.embedders.add(embedder)
 
     def add_memory_client(self, memory_client: str):
-        self.memory_clients.add(memory_client)  # pylint: disable=no-member
+        self.memory_clients.add(memory_client)
 
     def add_object_store(self, object_store: str):
-        self.object_stores.add(object_store)  # pylint: disable=no-member
+        self.object_stores.add(object_store)
 
     def add_retriever(self, retriever: str):
-        self.retrievers.add(retriever)  # pylint: disable=no-member
+        self.retrievers.add(retriever)

nat/data_models/intermediate_step.py

@@ -142,7 +142,7 @@ class IntermediateStepPayload(BaseModel):
     UUID: str = Field(default_factory=lambda: str(uuid.uuid4()))
 
     @property
-    def event_category(self) -> IntermediateStepCategory:  # pylint: disable=too-many-return-statements
+    def event_category(self) -> IntermediateStepCategory:
         match self.event_type:
             case IntermediateStepType.LLM_START:
                 return IntermediateStepCategory.LLM
@@ -180,7 +180,7 @@ class IntermediateStepPayload(BaseModel):
                 raise ValueError(f"Unknown event type: {self.event_type}")
 
     @property
-    def event_state(self) -> IntermediateStepState:  # pylint: disable=too-many-return-statements
+    def event_state(self) -> IntermediateStepState:
         match self.event_type:
             case IntermediateStepType.LLM_START:
                 return IntermediateStepState.START
@@ -290,7 +290,7 @@ class IntermediateStep(BaseModel):
         return self.payload.usage_info
 
     @property
-    def UUID(self) -> str:  # pylint: disable=invalid-name
+    def UUID(self) -> str:
         return self.payload.UUID
 
     @property

nat/data_models/model_gated_field_mixin.py

@@ -0,0 +1,125 @@
+# 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 collections.abc import Sequence
+from re import Pattern
+from typing import Generic
+from typing import TypeVar
+
+from pydantic import BaseModel
+from pydantic import model_validator
+
+T = TypeVar("T")
+
+
+class ModelGatedFieldMixin(Generic[T]):
+    """
+    A mixin that gates a field based on model support.
+
+    This should be used to automatically validate a field based on a given model.
+
+    Parameters
+    ----------
+    field_name: `str`
+                The name of the field.
+    default_if_supported: `T`
+                          The default value of the field if it is supported for the model.
+    unsupported_models: `Sequence[Pattern[str]] | None`
+                        A sequence of regex patterns that match the model names NOT supported for the field.
+                        Defaults to None.
+    supported_models: `Sequence[Pattern[str]] | None`
+                      A sequence of regex patterns that match the model names supported for the field.
+                      Defaults to None.
+    model_keys: `Sequence[str]`
+                A sequence of keys that are used to validate the field.
+                Defaults to ("model_name", "model", "azure_deployment",)
+    """
+
+    def __init_subclass__(
+            cls,
+            field_name: str | None = None,
+            default_if_supported: T | None = None,
+            unsupported_models: Sequence[Pattern[str]] | None = None,
+            supported_models: Sequence[Pattern[str]] | None = None,
+            model_keys: Sequence[str] = ("model_name", "model", "azure_deployment"),
+    ) -> None:
+        """
+        Store the class variables for the field and define the model validator.
+        """
+        super().__init_subclass__()
+        if ModelGatedFieldMixin in cls.__bases__:
+            if field_name is None:
+                raise ValueError("field_name must be provided when subclassing ModelGatedFieldMixin")
+            if default_if_supported is None:
+                raise ValueError("default_if_supported must be provided when subclassing ModelGatedFieldMixin")
+            if unsupported_models is None and supported_models is None:
+                raise ValueError("Either unsupported_models or supported_models must be provided")
+            if unsupported_models is not None and supported_models is not None:
+                raise ValueError("Only one of unsupported_models or supported_models must be provided")
+            if model_keys is not None and len(model_keys) == 0:
+                raise ValueError("model_keys must be provided and non-empty when subclassing ModelGatedFieldMixin")
+            cls.field_name = field_name
+            cls.default_if_supported = default_if_supported
+            cls.unsupported_models = unsupported_models
+            cls.supported_models = supported_models
+            if model_keys is not None:
+                cls.model_keys = model_keys
+
+            @classmethod
+            def check_model(cls, model_name: str) -> bool:
+                """
+                Check if a model is supported for a given field.
+
+                Args:
+                    model_name: The name of the model to check.
+                """
+                unsupported = getattr(cls, "unsupported_models", None)
+                supported = getattr(cls, "supported_models", None)
+                if unsupported is not None:
+                    return not any(p.search(model_name) for p in unsupported)
+                if supported is not None:
+                    return any(p.search(model_name) for p in supported)
+                return False
+
+            cls._model_gated_field_check_model = check_model
+
+            @classmethod
+            def detect_support(cls, instance: BaseModel) -> str | None:
+                for key in getattr(cls, "model_keys"):
+                    if hasattr(instance, key):
+                        model_name_value = getattr(instance, key)
+                        is_supported = getattr(cls, "_model_gated_field_check_model")(str(model_name_value))
+                        return key if not is_supported else None
+                return None
+
+            cls._model_gated_field_detect_support = detect_support
+
+            @model_validator(mode="after")
+            def model_validate(self):
+                klass = self.__class__
+
+                field_name_local = getattr(klass, "field_name")
+                current_value = getattr(self, field_name_local, None)
+
+                found_key = klass._model_gated_field_detect_support(self)
+                if found_key is not None:
+                    if current_value is not None:
+                        raise ValueError(
+                            f"{field_name_local} is not supported for {found_key}: {getattr(self, found_key)}")
+                elif current_value is None:
+                    setattr(self, field_name_local, getattr(klass, "default_if_supported", None))
+                return self
+
+            cls._model_gated_field_model_validator = model_validate

nat/data_models/swe_bench_model.py

@@ -39,7 +39,7 @@ class SWEBenchInput(BaseModel):
 
     # Handle improperly formatted JSON strings for list fields
     @field_validator("FAIL_TO_PASS", "PASS_TO_PASS", mode="before")
-    def parse_list_fields(cls, value):  # pylint: disable=no-self-argument
+    def parse_list_fields(cls, value):
         if isinstance(value, str):
             # Attempt to parse the string as a list
             return json.loads(value)