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

nat/llm/openai_llm.py

@@ -22,9 +22,11 @@ from nat.builder.llm import LLMProviderInfo
 from nat.cli.register_workflow import register_llm_provider
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.retry_mixin import RetryMixin
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.top_p_mixin import TopPMixin
 
 
-class OpenAIModelConfig(LLMBaseConfig, RetryMixin, name="openai"):
+class OpenAIModelConfig(LLMBaseConfig, RetryMixin, TemperatureMixin, TopPMixin, name="openai"):
     """An OpenAI LLM provider to be used with an LLM client."""
 
     model_config = ConfigDict(protected_namespaces=(), extra="allow")
@@ -34,13 +36,11 @@ class OpenAIModelConfig(LLMBaseConfig, RetryMixin, name="openai"):
     model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
                             serialization_alias="model",
                             description="The OpenAI hosted model name.")
-    temperature: float = Field(default=0.0, description="Sampling temperature in [0, 1].")
-    top_p: float = Field(default=1.0, description="Top-p for distribution sampling.")
     seed: int | None = Field(default=None, description="Random seed to set for generation.")
     max_retries: int = Field(default=10, description="The max number of retries for the request.")
 
 
 @register_llm_provider(config_type=OpenAIModelConfig)
-async def openai_llm(config: OpenAIModelConfig, builder: Builder):
+async def openai_llm(config: OpenAIModelConfig, _builder: Builder):
 
     yield LLMProviderInfo(config=config, description="An OpenAI model for use with an LLM client.")

nat/llm/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
 # isort:skip_file
 

nat/llm/utils/env_config_value.py

@@ -72,9 +72,8 @@ class EnvConfigValue(ABC):
                     f"{message} Try passing a value to the constructor, or setting the `{self.__class__._ENV_KEY}` "
                     "environment variable.")
 
-        else:
-            if not self.__class__._ALLOW_NONE and value is None:
-                raise ValueError("value must not be none")
+        elif not self.__class__._ALLOW_NONE and value is None:
+            raise ValueError("value must not be none")
 
         assert isinstance(value, str) or value is None
 

nat/object_store/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
 # isort:skip_file
 

nat/observability/exporter/file_exporter.py

@@ -24,7 +24,7 @@ from nat.observability.processor.intermediate_step_serializer import Intermediat
 logger = logging.getLogger(__name__)
 
 
-class FileExporter(FileExportMixin, RawExporter[IntermediateStep, str]):  # pylint: disable=R0901
+class FileExporter(FileExportMixin, RawExporter[IntermediateStep, str]):
     """A File exporter that exports telemetry traces to a local file."""
 
     def __init__(self, context_state: ContextState | None = None, **file_kwargs):

nat/observability/register.py

@@ -45,7 +45,7 @@ class FileTelemetryExporterConfig(TelemetryExporterBaseConfig, name="file"):
 
 
 @register_telemetry_exporter(config_type=FileTelemetryExporterConfig)
-async def file_telemetry_exporter(config: FileTelemetryExporterConfig, builder: Builder):  # pylint: disable=W0613
+async def file_telemetry_exporter(config: FileTelemetryExporterConfig, builder: Builder):
     """
     Build and return a FileExporter for file-based telemetry export with optional rolling.
     """
@@ -68,7 +68,7 @@ class ConsoleLoggingMethodConfig(LoggingBaseConfig, name="console"):
 
 
 @register_logging_method(config_type=ConsoleLoggingMethodConfig)
-async def console_logging_method(config: ConsoleLoggingMethodConfig, builder: Builder):  # pylint: disable=W0613
+async def console_logging_method(config: ConsoleLoggingMethodConfig, builder: Builder):
     """
     Build and return a StreamHandler for console-based logging.
     """
@@ -86,7 +86,7 @@ class FileLoggingMethod(LoggingBaseConfig, name="file"):
 
 
 @register_logging_method(config_type=FileLoggingMethod)
-async def file_logging_method(config: FileLoggingMethod, builder: Builder):  # pylint: disable=W0613
+async def file_logging_method(config: FileLoggingMethod, builder: Builder):
     """
     Build and return a FileHandler for file-based logging.
     """

nat/profiler/callbacks/langchain_callback_handler.py

@@ -53,7 +53,7 @@ def _extract_tools_schema(invocation_params: dict) -> list:
     return tools_schema
 
 
-class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):  # pylint: disable=R0901
+class LangchainProfilerHandler(AsyncCallbackHandler, BaseProfilerCallback):
     """Callback Handler that tracks NIM info."""
 
     total_tokens: int = 0

nat/profiler/callbacks/semantic_kernel_callback_handler.py

@@ -86,7 +86,7 @@ class SemanticKernelProfilerHandler(BaseProfilerCallback):
 
         # Gather the appropriate modules/functions based on your builder config
         for llm in self._builder_llms:
-            if self._builder_llms[llm].provider_type == 'openai':  # pylint: disable=consider-using-in
+            if self._builder_llms[llm].provider_type == 'openai':
                 functions_to_patch.extend(["openai_non_streaming", "openai_streaming"])
 
         # Grab original reference for the tool call

nat/profiler/data_frame_row.py

@@ -42,7 +42,7 @@ class DataFrameRow(BaseModel):
     framework: str | None
 
     @field_validator('llm_text_input', 'llm_text_output', 'llm_new_token', mode='before')
-    def cast_to_str(cls, v):  # pylint: disable=no-self-argument
+    def cast_to_str(cls, v):
         if v is None:
             return v
         try:

nat/profiler/decorators/framework_wrapper.py

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint disable=ungrouped-imports
-
 from __future__ import annotations
 
 import functools
@@ -75,8 +73,7 @@ def set_framework_profiler_handler(
                 logger.debug("LlamaIndex callback handler registered")
 
             if LLMFrameworkEnum.CREWAI in frameworks and not _library_instrumented["crewai"]:
-                from nat.plugins.crewai.crewai_callback_handler import \
-                    CrewAIProfilerHandler  # pylint: disable=ungrouped-imports,line-too-long  # noqa E501
+                from nat.plugins.crewai.crewai_callback_handler import CrewAIProfilerHandler
 
                 handler = CrewAIProfilerHandler()
                 handler.instrument()

nat/profiler/forecasting/models/forecasting_base_model.py

@@ -15,7 +15,9 @@
 
 # forecasting/models/base_model.py
 
-from abc import ABC, abstractmethod
+from abc import ABC
+from abc import abstractmethod
+
 import numpy as np
 
 

nat/profiler/inference_optimization/bottleneck_analysis/simple_stack_analysis.py

@@ -195,7 +195,7 @@ def profile_workflow_bottlenecks(all_steps: list[list[IntermediateStep]]) -> Sim
         c_max = 0
         for ts, delta in events_sub:
             c_curr += delta
-            if c_curr > c_max:  # pylint: disable=consider-using-max-builtin
+            if c_curr > c_max:  # noqa: PLR1730 - don't use max built-in
                 c_max = c_curr
         max_concurrency_by_name[op_name] = c_max
 

nat/profiler/inference_optimization/data_models.py

@@ -172,7 +172,7 @@ class CallNode(BaseModel):
         if not self.children:
             return self.duration
 
-        intervals = [(c.start_time, c.end_time) for c in self.children]  # pylint: disable=not-an-iterable
+        intervals = [(c.start_time, c.end_time) for c in self.children]
         # Sort by start time
         intervals.sort(key=lambda x: x[0])
 
@@ -204,7 +204,7 @@ class CallNode(BaseModel):
         This ensures no overlap double-counting among children.
         """
         total = self.compute_self_time()
-        for c in self.children:  # pylint: disable=not-an-iterable
+        for c in self.children:
             total += c.compute_subtree_time()
         return total
 
@@ -216,7 +216,7 @@ class CallNode(BaseModel):
         info = (f"{indent}- {self.operation_type} '{self.operation_name}' "
                 f"(uuid={self.uuid}, start={self.start_time:.2f}, "
                 f"end={self.end_time:.2f}, dur={self.duration:.2f})")
-        child_strs = [child._repr(level + 1) for child in self.children]  # pylint: disable=not-an-iterable
+        child_strs = [child._repr(level + 1) for child in self.children]
         return "\n".join([info] + child_strs)
 
 

nat/profiler/inference_optimization/experimental/prefix_span_analysis.py

@@ -228,7 +228,7 @@ def run_prefixspan(sequences_map: dict[int, list[PrefixCallNode]],
     else:
         abs_min_support = min_support
 
-    freq_patterns = ps.frequent(abs_min_support)  # pylint: disable=not-callable
+    freq_patterns = ps.frequent(abs_min_support)
     # freq_patterns => [(count, [item1, item2, ...])]
 
     results = []
@@ -321,13 +321,12 @@ def compute_coverage_and_duration(sequences_map: dict[int, list[PrefixCallNode]]
 # --------------------------------------------------------------------------------
 
 
-def prefixspan_subworkflow_with_text(  # pylint: disable=too-many-positional-arguments
-        all_steps: list[list[IntermediateStep]],
-        min_support: int | float = 2,
-        top_k: int = 10,
-        min_coverage: float = 0.0,
-        max_text_len: int = 700,
-        prefix_list: list[str] = None) -> PrefixSpanSubworkflowResult:
+def prefixspan_subworkflow_with_text(all_steps: list[list[IntermediateStep]],
+                                     min_support: int | float = 2,
+                                     top_k: int = 10,
+                                     min_coverage: float = 0.0,
+                                     max_text_len: int = 700,
+                                     prefix_list: list[str] = None) -> PrefixSpanSubworkflowResult:
     """
     1) Build sequences of calls for each example (with llm_text_input).
     2) Convert to token lists, run PrefixSpan with min_support.

nat/profiler/inference_optimization/token_uniqueness.py

@@ -66,7 +66,7 @@ def compute_inter_query_token_uniqueness_by_llm(all_steps: list[list[Intermediat
     # 2) Group by (llm_name, example_number), then sort each group
     grouped = cdf.groupby(['llm_name', 'example_number'], as_index=False, group_keys=True)
 
-    for (llm, ex_num), group_df in grouped:  # pylint: disable=unused-variable
+    for (llm, ex_num), group_df in grouped:
         # Sort by event_timestamp
         group_df = group_df.sort_values('event_timestamp', ascending=True)
 

nat/profiler/profile_runner.py

@@ -88,14 +88,19 @@ class ProfilerRunner:
         writes out combined requests JSON, then computes and saves additional metrics,
         and optionally fits a forecasting model.
         """
-        from nat.profiler.inference_optimization.bottleneck_analysis.nested_stack_analysis import \
-            multi_example_call_profiling
-        from nat.profiler.inference_optimization.bottleneck_analysis.simple_stack_analysis import \
-            profile_workflow_bottlenecks
-        from nat.profiler.inference_optimization.experimental.concurrency_spike_analysis import \
-            concurrency_spike_analysis
-        from nat.profiler.inference_optimization.experimental.prefix_span_analysis import \
-            prefixspan_subworkflow_with_text
+        # Yapf and ruff disagree on how to format long imports, disable yapf go with ruff
+        from nat.profiler.inference_optimization.bottleneck_analysis.nested_stack_analysis import (
+            multi_example_call_profiling,
+        )  # yapf: disable
+        from nat.profiler.inference_optimization.bottleneck_analysis.simple_stack_analysis import (
+            profile_workflow_bottlenecks,
+        )  # yapf: disable
+        from nat.profiler.inference_optimization.experimental.concurrency_spike_analysis import (
+            concurrency_spike_analysis,
+        )  # yapf: disable
+        from nat.profiler.inference_optimization.experimental.prefix_span_analysis import (
+            prefixspan_subworkflow_with_text,
+        )  # yapf: disable
         from nat.profiler.inference_optimization.llm_metrics import LLMMetrics
         from nat.profiler.inference_optimization.prompt_caching import get_common_prefixes
         from nat.profiler.inference_optimization.token_uniqueness import compute_inter_query_token_uniqueness_by_llm

nat/registry_handlers/package_utils.py

@@ -29,7 +29,6 @@ from nat.registry_handlers.schemas.publish import Artifact
 from nat.runtime.loader import PluginTypes
 from nat.runtime.loader import discover_entrypoints
 
-# pylint: disable=redefined-outer-name
 logger = logging.getLogger(__name__)
 
 

nat/registry_handlers/pypi/pypi_handler.py

@@ -44,13 +44,12 @@ class PypiRegistryHandler(AbstractRegistryHandler):
     https://github.com/pypiserver/pypiserver
     """
 
-    def __init__(  # pylint: disable=R0917
-            self,
-            endpoint: str,
-            token: str | None = None,
-            publish_route: str = "",
-            pull_route: str = "",
-            search_route: str = ""):
+    def __init__(self,
+                 endpoint: str,
+                 token: str | None = None,
+                 publish_route: str = "",
+                 pull_route: str = "",
+                 search_route: str = ""):
         super().__init__()
         self._endpoint = endpoint.rstrip("/")
         self._token = token
@@ -126,17 +125,16 @@ class PypiRegistryHandler(AbstractRegistryHandler):
 
             versioned_packages_str = " ".join(versioned_packages)
 
-            result = subprocess.run(
-                [
-                    "uv",
-                    "pip",
-                    "install",
-                    "--prerelease=allow",
-                    "--index-url",
-                    f"{self._endpoint}/{self._pull_route}/",
-                    versioned_packages_str
-                ],  # pylint: disable=W0631
-                check=True)
+            result = subprocess.run([
+                "uv",
+                "pip",
+                "install",
+                "--prerelease=allow",
+                "--index-url",
+                f"{self._endpoint}/{self._pull_route}/",
+                versioned_packages_str
+            ],
+                                    check=True)
 
             result.check_returncode()
 
@@ -171,11 +169,10 @@ class PypiRegistryHandler(AbstractRegistryHandler):
         """
 
         try:
-            completed_process = subprocess.run(
-                ["pip", "search", "--index", f"{self._endpoint}", query.query],  # pylint: disable=W0631
-                text=True,
-                capture_output=True,
-                check=True)
+            completed_process = subprocess.run(["pip", "search", "--index", f"{self._endpoint}", query.query],
+                                               text=True,
+                                               capture_output=True,
+                                               check=True)
             search_response_list = []
             search_results = completed_process.stdout
             package_results = search_results.split("\n")

nat/registry_handlers/register.py

@@ -13,9 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=unused-import
 # flake8: noqa
 
-from .local import register_local  # pylint: disable=E0611
-from .pypi import register_pypi  # pylint: disable=E0611
-from .rest import register_rest  # pylint: disable=E0611
+from .local import register_local
+from .pypi import register_pypi
+from .rest import register_rest

nat/registry_handlers/rest/rest_handler.py

@@ -42,15 +42,14 @@ logger = logging.getLogger(__name__)
 class RestRegistryHandler(AbstractRegistryHandler):
     """A registry handler for interactions with a remote REST registry."""
 
-    def __init__(  # pylint: disable=R0917
-            self,
-            endpoint: str,
-            token: str,
-            timeout: int = 30,
-            publish_route: str = "",
-            pull_route: str = "",
-            search_route: str = "",
-            remove_route: str = ""):
+    def __init__(self,
+                 endpoint: str,
+                 token: str,
+                 timeout: int = 30,
+                 publish_route: str = "",
+                 pull_route: str = "",
+                 search_route: str = "",
+                 remove_route: str = ""):
         super().__init__()
         self._endpoint = endpoint.rstrip("/")
         self._timeout = timeout

nat/retriever/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
 # isort:skip_file
 

nat/runtime/session.py

@@ -21,7 +21,9 @@ from collections.abc import Callable
 from contextlib import asynccontextmanager
 from contextlib import nullcontext
 
+from fastapi import WebSocket
 from starlette.requests import HTTPConnection
+from starlette.requests import Request
 
 from nat.builder.context import Context
 from nat.builder.context import ContextState
@@ -89,7 +91,8 @@ class SessionManager:
     @asynccontextmanager
     async def session(self,
                       user_manager=None,
-                      request: HTTPConnection | None = None,
+                      http_connection: HTTPConnection | None = None,
+                      user_message_id: str | None = None,
                       conversation_id: str | None = None,
                       user_input_callback: Callable[[InteractionPrompt], Awaitable[HumanResponse]] = None,
                       user_authentication_callback: Callable[[AuthProviderBaseConfig, AuthFlowType],
@@ -107,10 +110,11 @@ class SessionManager:
         if user_authentication_callback is not None:
             token_user_authentication = self._context_state.user_auth_callback.set(user_authentication_callback)
 
-        if conversation_id is not None and request is None:
-            self._context_state.conversation_id.set(conversation_id)
+        if isinstance(http_connection, WebSocket):
+            self.set_metadata_from_websocket(user_message_id, conversation_id)
 
-        self.set_metadata_from_http_request(request)
+        if isinstance(http_connection, Request):
+            self.set_metadata_from_http_request(http_connection)
 
         try:
             yield self
@@ -135,14 +139,11 @@ class SessionManager:
             async with self._workflow.run(message) as runner:
                 yield runner
 
-    def set_metadata_from_http_request(self, request: HTTPConnection | None) -> None:
+    def set_metadata_from_http_request(self, request: Request) -> None:
         """
         Extracts and sets user metadata request attributes from a HTTP request.
         If request is None, no attributes are set.
         """
-        if request is None:
-            return
-
         self._context.metadata._request.method = getattr(request, "method", None)
         self._context.metadata._request.url_path = request.url.path
         self._context.metadata._request.url_port = request.url.port
@@ -157,6 +158,20 @@ class SessionManager:
         if request.headers.get("conversation-id"):
             self._context_state.conversation_id.set(request.headers["conversation-id"])
 
+        if request.headers.get("user-message-id"):
+            self._context_state.user_message_id.set(request.headers["user-message-id"])
+
+    def set_metadata_from_websocket(self, user_message_id: str | None, conversation_id: str | None) -> None:
+        """
+        Extracts and sets user metadata for Websocket connections.
+        """
+
+        if conversation_id is not None:
+            self._context_state.conversation_id.set(conversation_id)
+
+        if user_message_id is not None:
+            self._context_state.user_message_id.set(user_message_id)
+
 
 # Compatibility aliases with previous releases
 AIQSessionManager = SessionManager

nat/settings/global_settings.py

@@ -124,7 +124,6 @@ class Settings(HashableBaseModel):
                 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)]
 
         RegistryHandlerAnnotation = dict[

nat/tool/code_execution/local_sandbox/local_sandbox_server.py

@@ -127,7 +127,7 @@ def execute_code_subprocess(generated_code: str, queue):
     stderr_capture = StringIO()
     try:
         with contextlib.redirect_stdout(stdout_capture), contextlib.redirect_stderr(stderr_capture):
-            exec(generated_code, {})  # pylint: disable=W0122
+            exec(generated_code, {})
         logger.debug("execute_code_subprocess finished, PID: %s", os.getpid())
         queue.put(CodeExecutionResult(stdout=stdout_capture.getvalue(), stderr=stderr_capture.getvalue()))
     except Exception as e:

nat/tool/document_search.py

@@ -53,7 +53,7 @@ async def document_search(config: MilvusDocumentSearchToolConfig, builder: Build
     from langchain_core.messages import HumanMessage
     from langchain_core.messages import SystemMessage
     from langchain_core.pydantic_v1 import BaseModel
-    from langchain_core.pydantic_v1 import Field  # pylint: disable=redefined-outer-name, reimported
+    from langchain_core.pydantic_v1 import Field
 
     # define collection store
     # create a list of tuples using enumerate()

nat/tool/mcp/mcp_tool.py

@@ -48,7 +48,7 @@ class MCPToolConfig(FunctionBaseConfig, name="mcp_tool_wrapper"):
 
 
 @register_function(config_type=MCPToolConfig)
-async def mcp_tool(config: MCPToolConfig, builder: Builder):  # pylint: disable=unused-argument
+async def mcp_tool(config: MCPToolConfig, builder: Builder):
     """
     Generate a NAT Function that wraps a tool provided by the MCP server.
     """

nat/tool/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 tools which need to be automatically registered here

nat/utils/data_models/schema_validator.py

@@ -21,7 +21,7 @@ from ..exception_handlers.schemas import yaml_exception_handler
 
 
 @schema_exception_handler
-def validate_schema(metadata, Schema):  # pylint: disable=invalid-name
+def validate_schema(metadata, Schema):
 
     try:
         return Schema(**metadata)
@@ -31,7 +31,7 @@ def validate_schema(metadata, Schema):  # pylint: disable=invalid-name
 
 
 @yaml_exception_handler
-def validate_yaml(ctx, param, value):  # pylint: disable=unused-argument
+def validate_yaml(ctx, param, value):
     """
     Validate that the file is a valid YAML file
 

nat/utils/exception_handlers/automatic_retries.py

@@ -26,8 +26,6 @@ from collections.abc import Sequence
 from typing import Any
 from typing import TypeVar
 
-# pylint: disable=inconsistent-return-statements
-
 T = TypeVar("T")
 Exc = tuple[type[BaseException], ...]  # exception classes
 CodePattern = int | str | range  # for retry_codes argument

nat/utils/exception_handlers/schemas.py

@@ -21,7 +21,7 @@ from pydantic import ValidationError
 logger = logging.getLogger(__name__)
 
 
-def schema_exception_handler(func, **kwargs):  # pylint: disable=unused-argument
+def schema_exception_handler(func, **kwargs):
     """
     A decorator that handles `ValidationError` exceptions for schema validation functions.
 

nat/utils/reactive/base/observable_base.py

@@ -25,8 +25,8 @@ from nat.utils.reactive.subscription import Subscription
 
 # Covariant type param: An Observable producing type X can also produce
 # a subtype of X.
-_T_out_co = TypeVar("_T_out_co", covariant=True)  # pylint: disable=invalid-name
-_T = TypeVar("_T")  # pylint: disable=invalid-name
+_T_out_co = TypeVar("_T_out_co", covariant=True)
+_T = TypeVar("_T")
 
 OnNext = Callable[[_T], None]
 OnError = Callable[[Exception], None]

nat/utils/reactive/base/observer_base.py

@@ -20,7 +20,7 @@ from typing import TypeVar
 
 # Contravariant type param: An Observer that can accept type X can also
 # accept any supertype of X.
-_T_in_contra = TypeVar("_T_in_contra", contravariant=True)  # pylint: disable=invalid-name
+_T_in_contra = TypeVar("_T_in_contra", contravariant=True)
 
 
 class ObserverBase(Generic[_T_in_contra], ABC):

nat/utils/reactive/observable.py

@@ -24,8 +24,8 @@ from nat.utils.type_utils import override
 
 # Covariant type param: An Observable producing type X can also produce
 # a subtype of X.
-_T_out_co = TypeVar("_T_out_co", covariant=True)  # pylint: disable=invalid-name
-_T = TypeVar("_T")  # pylint: disable=invalid-name
+_T_out_co = TypeVar("_T_out_co", covariant=True)
+_T = TypeVar("_T")
 
 OnNext = Callable[[_T], None]
 OnError = Callable[[Exception], None]

nat/utils/reactive/observer.py

@@ -23,8 +23,8 @@ logger = logging.getLogger(__name__)
 
 # Contravariant type param: An Observer that can accept type X can also
 # accept any supertype of X.
-_T_in_contra = TypeVar("_T_in_contra", contravariant=True)  # pylint: disable=invalid-name
-_T = TypeVar("_T")  # pylint: disable=invalid-name
+_T_in_contra = TypeVar("_T_in_contra", contravariant=True)
+_T = TypeVar("_T")
 
 OnNext = Callable[[_T], None]
 OnError = Callable[[Exception], None]

nat/utils/reactive/subscription.py

@@ -21,7 +21,7 @@ from typing import TypeVar
 if typing.TYPE_CHECKING:
     from nat.utils.reactive.base.subject_base import SubjectBase
 
-_T = TypeVar("_T")  # pylint: disable=invalid-name
+_T = TypeVar("_T")
 
 OnNext = Callable[[_T], None]
 OnError = Callable[[Exception], None]