nvidia-nat 1.3.0a20250909__py3-none-any.whl → 1.3.0a20250917__py3-none-any.whl

nat/observability/processor/header_redaction_processor.py

@@ -1,123 +0,0 @@
-# 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 logging
-from collections.abc import Callable
-from functools import lru_cache
-
-from starlette.datastructures import Headers
-
-from nat.builder.context import Context
-from nat.data_models.span import Span
-from nat.observability.processor.redaction_processor import SpanRedactionProcessor
-from nat.utils.type_utils import override
-
-logger = logging.getLogger(__name__)
-
-
-def default_callback(_auth_key: str) -> bool:
-    """Default callback that always returns False."""
-    return False
-
-
-class HeaderRedactionProcessor(SpanRedactionProcessor):
-    """Processor that redacts the span based on auth key, span attributes, and callback.
-
-    Uses an LRU cache to avoid redundant callback executions for the same auth keys,
-    providing bounded memory usage and automatic eviction of least recently used entries.
-
-    Args:
-        attributes: List of span attribute keys to redact.
-        header: The header key to check for authentication.
-        callback: Function to determine if the auth key should trigger redaction.
-        enabled: Whether the processor is enabled (default: True).
-        force_redact: If True, always redact regardless of header checks (default: False).
-        redaction_value: The value to replace redacted attributes with (default: "[REDACTED]").
-    """
-
-    def __init__(self,
-                 attributes: list[str] | None = None,
-                 header: str | None = None,
-                 callback: Callable[[str], bool] | None = None,
-                 enabled: bool = True,
-                 force_redact: bool = False,
-                 redaction_value: str = "[REDACTED]"):
-        self.attributes = attributes or []
-        self.header = header
-        self.callback = callback or default_callback
-        self.enabled = enabled
-        self.force_redact = force_redact
-        self.redaction_value = redaction_value
-
-    @override
-    def should_redact(self, item: Span, context: Context) -> bool:
-        """Determine if this span should be redacted based on header auth.
-
-        Args:
-            item (Span): The span to check.
-            context (Context): The current context.
-
-        Returns:
-            bool: True if the span should be redacted, False otherwise.
-        """
-        # If force_redact is enabled, always redact regardless of other conditions
-        if self.force_redact:
-            return True
-
-        if not self.enabled:
-            return False
-
-        headers: Headers | None = context.metadata.headers
-
-        if headers is None or self.header is None:
-            return False
-
-        auth_key = headers.get(self.header, None)
-
-        if not auth_key:
-            return False
-
-        # Use LRU cached method to determine if redaction is needed
-        return self._should_redact_impl(auth_key)
-
-    @lru_cache(maxsize=128)
-    def _should_redact_impl(self, auth_key: str) -> bool:
-        """Implementation method for checking if redaction should occur.
-
-        This method uses lru_cache to avoid redundant callback executions.
-
-        Args:
-            auth_key (str): The authentication key to check.
-
-        Returns:
-            bool: True if the span should be redacted, False otherwise.
-        """
-        return self.callback(auth_key)
-
-    @override
-    def redact_item(self, item: Span) -> Span:
-        """Redact the span.
-
-        Args:
-            item (Span): The span to redact.
-
-        Returns:
-            Span: The redacted span.
-        """
-        for key in self.attributes:
-            if key in item.attributes:
-                item.attributes[key] = self.redaction_value
-
-        return item

nat/observability/processor/redaction_processor.py

@@ -1,77 +0,0 @@
-# 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 logging
-from abc import ABC
-from abc import abstractmethod
-from typing import TypeVar
-
-from nat.builder.context import Context
-from nat.data_models.span import Span
-from nat.observability.processor.processor import Processor
-from nat.utils.type_utils import override
-
-RedactionItemT = TypeVar('RedactionItemT')
-
-logger = logging.getLogger(__name__)
-
-
-class RedactionProcessor(Processor[RedactionItemT, RedactionItemT], ABC):
-    """Abstract base class for redaction processors."""
-
-    @abstractmethod
-    def should_redact(self, item: RedactionItemT, context: Context) -> bool:
-        """Determine if this item should be redacted.
-
-        Args:
-            item (RedactionItemT): The item to check.
-            context (Context): The current context.
-
-        Returns:
-            bool: True if the item should be redacted, False otherwise.
-        """
-        pass
-
-    @abstractmethod
-    def redact_item(self, item: RedactionItemT) -> RedactionItemT:
-        """Redact the item.
-
-        Args:
-            item (RedactionItemT): The item to redact.
-
-        Returns:
-            RedactionItemT: The redacted item.
-        """
-        pass
-
-    @override
-    async def process(self, item: RedactionItemT) -> RedactionItemT:
-        """Perform redaction on the item if it should be redacted.
-
-        Args:
-            item (RedactionItemT): The item to process.
-
-        Returns:
-            RedactionItemT: The processed item.
-        """
-        context = Context.get()
-        if self.should_redact(item, context):
-            return self.redact_item(item)
-        return item
-
-
-class SpanRedactionProcessor(RedactionProcessor[Span]):
-    """Abstract base class for span redaction processors."""
-    pass

nat/tool/github_tools/create_github_commit.py

@@ -1,133 +0,0 @@
-# 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 pydantic import BaseModel
-from pydantic import Field
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-
-
-class GithubCommitCodeModel(BaseModel):
-    branch: str = Field(description="The branch of the remote repo to which the code will be committed")
-    commit_msg: str = Field(description="Message with which the code will be committed to the remote repo")
-    local_path: str = Field(description="Local filepath of the file that has been updated and "
-                            "needs to be committed to the remote repo")
-    remote_path: str = Field(description="Remote filepath of the updated file in GitHub. Path is relative to "
-                             "root of current repository")
-
-
-class GithubCommitCodeModelList(BaseModel):
-    updated_files: list[GithubCommitCodeModel] = Field(description=("A list of local filepaths and commit messages"))
-
-
-class GithubCommitCodeConfig(FunctionBaseConfig, name="github_commit_code_tool"):
-    """
-    Tool that commits and pushes modified code to a remote GitHub repository asynchronously.
-    """
-    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
-    local_repo_dir: str = Field(description="Absolute path to the root of the repo, cloned locally")
-    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
-
-
-@register_function(config_type=GithubCommitCodeConfig)
-async def commit_code_async(config: GithubCommitCodeConfig, builder: Builder):
-    """
-    Commits and pushes modified code to a remote GitHub repository asynchronously.
-
-    """
-    import json
-    import os
-
-    import httpx
-
-    github_pat = os.getenv("GITHUB_PAT")
-    if not github_pat:
-        raise ValueError("GITHUB_PAT environment variable must be set")
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_commit_code(updated_files) -> list:
-        results = []
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            for file_ in updated_files:
-                branch = file_.branch
-                commit_msg = file_.commit_msg
-                local_path = file_.local_path
-                remote_path = file_.remote_path
-
-                # Read content from the local file
-                local_path = os.path.join(config.local_repo_dir, local_path)
-                with open(local_path, 'r', encoding='utf-8', errors='ignore') as f:
-                    content = f.read()
-
-                # Step 1. Create a blob with the updated contents of the file
-                blob_url = f'https://api.github.com/repos/{config.repo_name}/git/blobs'
-                blob_data = {'content': content, 'encoding': 'utf-8'}
-                blob_response = await client.request("POST", blob_url, json=blob_data, headers=headers)
-                blob_response.raise_for_status()
-                blob_sha = blob_response.json()['sha']
-
-                # Step 2: Get the base tree SHA. The commit will be pushed to this ref node in the Git graph
-                ref_url = f'https://api.github.com/repos/{config.repo_name}/git/refs/heads/{branch}'
-                ref_response = await client.request("GET", ref_url, headers=headers)
-                ref_response.raise_for_status()
-                base_tree_sha = ref_response.json()['object']['sha']
-
-                # Step 3. Create an updated tree (Git graph) with the new blob
-                tree_url = f'https://api.github.com/repos/{config.repo_name}/git/trees'
-                tree_data = {
-                    'base_tree': base_tree_sha,
-                    'tree': [{
-                        'path': remote_path, 'mode': '100644', 'type': 'blob', 'sha': blob_sha
-                    }]
-                }
-                tree_response = await client.request("POST", tree_url, json=tree_data, headers=headers)
-                tree_response.raise_for_status()
-                tree_sha = tree_response.json()['sha']
-
-                # Step 4: Create a commit
-                commit_url = f'https://api.github.com/repos/{config.repo_name}/git/commits'
-                commit_data = {'message': commit_msg, 'tree': tree_sha, 'parents': [base_tree_sha]}
-                commit_response = await client.request("POST", commit_url, json=commit_data, headers=headers)
-                commit_response.raise_for_status()
-                commit_sha = commit_response.json()['sha']
-
-                # Step 5: Update the reference in the Git graph
-                update_ref_url = f'https://api.github.com/repos/{config.repo_name}/git/refs/heads/{branch}'
-                update_ref_data = {'sha': commit_sha}
-                update_ref_response = await client.request("PATCH",
-                                                           update_ref_url,
-                                                           json=update_ref_data,
-                                                           headers=headers)
-                update_ref_response.raise_for_status()
-
-                payload_responses = {
-                    'blob_resp': blob_response.json(),
-                    'original_tree_ref': tree_response.json(),
-                    'commit_resp': commit_response.json(),
-                    'updated_tree_ref_resp': update_ref_response.json()
-                }
-                results.append(payload_responses)
-
-        return json.dumps(results)
-
-    yield FunctionInfo.from_fn(_github_commit_code,
-                               description=(f"Commits and pushes modified code to a "
-                                            f"GitHub repository in the repo named {config.repo_name}"),
-                               input_schema=GithubCommitCodeModelList)

nat/tool/github_tools/create_github_issue.py

@@ -1,87 +0,0 @@
-# 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 pydantic import BaseModel
-from pydantic import Field
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-
-
-class GithubCreateIssueModel(BaseModel):
-    title: str = Field(description="The title of the GitHub Issue")
-    body: str = Field(description="The body of the GitHub Issue")
-
-
-class GithubCreateIssueModelList(BaseModel):
-    issues: list[GithubCreateIssueModel] = Field(description=("A list of GitHub issues, "
-                                                              "each with a title and a body"))
-
-
-class GithubCreateIssueToolConfig(FunctionBaseConfig, name="github_create_issue_tool"):
-    """
-    Tool that creates an issue in a GitHub repository asynchronously.
-    """
-    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
-    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
-
-
-@register_function(config_type=GithubCreateIssueToolConfig)
-async def create_github_issue_async(config: GithubCreateIssueToolConfig, builder: Builder):
-    """
-    Creates an issue in a GitHub repository asynchronously.
-    """
-    import json
-    import os
-
-    import httpx
-
-    github_pat = os.getenv("GITHUB_PAT")
-    if not github_pat:
-        raise ValueError("GITHUB_PAT environment variable must be set")
-
-    url = f"https://api.github.com/repos/{config.repo_name}/issues"
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_post_issue(issues) -> list:
-        results = []
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            for issue in issues:
-                # define the payload body
-                payload = issue.dict(exclude_unset=True)
-
-                response = await client.request("POST", url, json=payload, headers=headers)
-
-                # Raise an exception for HTTP errors
-                response.raise_for_status()
-
-                # Parse and return the response JSON
-                try:
-                    result = response.json()
-                    results.append(result)
-
-                except ValueError as e:
-                    raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(results)
-
-    yield FunctionInfo.from_fn(_github_post_issue,
-                               description=(f"Creates a GitHub issue in the "
-                                            f"repo named {config.repo_name}"),
-                               input_schema=GithubCreateIssueModelList)

nat/tool/github_tools/create_github_pr.py

@@ -1,106 +0,0 @@
-# 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 pydantic import BaseModel
-from pydantic import Field
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-
-
-class GithubCreatePullModel(BaseModel):
-    title: str = Field(description="Title of the pull request")
-    body: str = Field(description="Description of the pull request")
-    source_branch: str = Field(description="The name of the branch containing your changes")
-    target_branch: str = Field(description="The name of the branch you want to merge into")
-    assignees: list[str] | None = Field([],
-                                        description="List of GitHub usernames to assign to the PR. "
-                                        "Always the current user")
-    reviewers: list[str] | None = Field([], description="List of GitHub usernames to request review from")
-
-
-class GithubCreatePullList(BaseModel):
-    pull_details: GithubCreatePullModel = Field(description=("A list of params used for creating the PR in GitHub"))
-
-
-class GithubCreatePullConfig(FunctionBaseConfig, name="github_create_pull_tool"):
-    """
-    Tool that creates a pull request in a GitHub repository asynchronously with assignees and reviewers.
-    """
-    repo_name: str = Field(description="The repository name in the format 'owner/repo'")
-    timeout: int = Field(default=300, description="The timeout configuration to use when sending requests.")
-
-
-@register_function(config_type=GithubCreatePullConfig)
-async def create_pull_request_async(config: GithubCreatePullConfig, builder: Builder):
-    """
-    Creates a pull request in a GitHub repository asynchronously with assignees and reviewers.
-
-    """
-    import json
-    import os
-
-    import httpx
-
-    github_pat = os.getenv("GITHUB_PAT")
-    if not github_pat:
-        raise ValueError("GITHUB_PAT environment variable must be set")
-
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_create_pull(pull_details: GithubCreatePullList) -> str:
-        results = []
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            # Create pull request
-            pr_url = f'https://api.github.com/repos/{config.repo_name}/pulls'
-            pr_data = {
-                'title': pull_details.title,
-                'body': pull_details.body,
-                'head': pull_details.source_branch,
-                'base': pull_details.target_branch
-            }
-
-            pr_response = await client.request("POST", pr_url, json=pr_data, headers=headers)
-            pr_response.raise_for_status()
-            pr_number = pr_response.json()['number']
-
-            # Add assignees if provided
-            if pull_details.assignees:
-                assignees_url = f'https://api.github.com/repos/{config.repo_name}/issues/{pr_number}/assignees'
-                assignees_data = {'assignees': pull_details.assignees}
-                assignees_response = await client.request("POST", assignees_url, json=assignees_data, headers=headers)
-                assignees_response.raise_for_status()
-
-            # Request reviewers if provided
-            if pull_details.reviewers:
-                reviewers_url = f'https://api.github.com/repos/{config.repo_name}/pulls/{pr_number}/requested_reviewers'
-                reviewers_data = {'reviewers': pull_details.reviewers}
-                reviewers_response = await client.request("POST", reviewers_url, json=reviewers_data, headers=headers)
-                reviewers_response.raise_for_status()
-
-            results.append({
-                'pull_request': pr_response.json(),
-                'assignees': assignees_response.json() if pull_details.assignees else None,
-                'reviewers': reviewers_response.json() if pull_details.reviewers else None
-            })
-
-        return json.dumps(results)
-
-    yield FunctionInfo.from_fn(_github_create_pull,
-                               description=(f"Creates a pull request with assignees and reviewers in the "
-                                            f"GitHub repository named {config.repo_name}"),
-                               input_schema=GithubCreatePullList)

nat/tool/github_tools/get_github_file.py

@@ -1,106 +0,0 @@
-# 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 nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-
-
-class GithubGetFileToolConfig(FunctionBaseConfig, name="github_getfile"):
-    """
-    Tool that returns the text of a github file using a github url starting with https://github.com and ending
-    with a specific file.
-    """
-    pass
-
-
-@register_function(config_type=GithubGetFileToolConfig)
-async def github_text_from_url(config: GithubGetFileToolConfig, builder: Builder):
-
-    import re
-
-    import requests
-
-    async def _github_text_from_url(url_text: str) -> str:
-
-        # Extract sections of the base github path
-        pattern = r"https://github.com/(.*)/blob/(.*)"
-        matches = re.findall(pattern, url_text)
-
-        if (len(matches) == 0):
-            return ("Invalid github url. Please provide a valid github url. "
-                    "Example: 'https://github.com/my_repository/blob/main/file.txt'")
-
-        # Construct raw content path
-        raw_url = f"https://raw.githubusercontent.com/{matches[0][0]}/refs/heads/{matches[0][1]}"
-        # Grab raw text from github
-        try:
-            response = requests.get(raw_url, timeout=60)
-        except requests.exceptions.Timeout:
-            return f"Timeout encountered when retrieving resource: {raw_url}"
-
-        return f"```python\n{response.text}\n```"
-
-    yield FunctionInfo.from_fn(_github_text_from_url,
-                               description=("Returns the text of a github file using a github url starting with"
-                                            "https://github.com and ending with a specific file."))
-
-
-class GithubGetFileLinesToolConfig(FunctionBaseConfig, name="github_getfilelines"):
-    """
-    Tool that returns the text lines of a github file using a github url starting with
-    https://github.com and ending with a specific file line references. Examples of line references are
-    #L409-L417 and #L166-L171.
-    """
-    pass
-
-
-@register_function(config_type=GithubGetFileLinesToolConfig)
-async def github_text_lines_from_url(config: GithubGetFileLinesToolConfig, builder: Builder):
-
-    import re
-
-    async def _github_text_lines_from_url(url_text: str) -> str:
-
-        import requests
-
-        # Extract sections of the base github path
-        pattern = r"https://github.com/(.*)/blob/(.*)(#L(\d+)-L(\d+))"
-        matches = re.findall(pattern, url_text)
-
-        if (len(matches) == 0):
-            return ("Invalid github url. Please provide a valid github url with line information. "
-                    "Example: 'https://github.com/my_repository/blob/main/file.txt#L409-L417'")
-
-        start_line, end_line = int(matches[0][3]), int(matches[0][4])
-        # Construct raw content path
-        raw_url = f"https://raw.githubusercontent.com/{matches[0][0]}/refs/heads/{matches[0][1]}"
-        # Grab raw text from github
-        try:
-            response = requests.get(raw_url, timeout=60)
-        except requests.exceptions.Timeout:
-            return f"Timeout encountered when retrieving resource: {raw_url}"
-        # Extract the specified lines
-        file_lines = response.text.splitlines()
-        selected_lines = file_lines[start_line:end_line]
-        joined_selected_lines = "\n".join(selected_lines)
-
-        return f"```python\n{joined_selected_lines}\n```"
-
-    yield FunctionInfo.from_fn(_github_text_lines_from_url,
-                               description=("Returns the text lines of a github file using a github url starting with"
-                                            "https://github.com and ending with a specific file line references. "
-                                            "Examples of line references are #L409-L417 and #L166-L171."))