nvidia-nat 1.3.0.dev2__py3-none-any.whl → 1.3.0rc2__py3-none-any.whl

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."))

nat/tool/github_tools/get_github_issue.py

@@ -1,166 +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 datetime import datetime
-from typing import Literal
-
-from pydantic import BaseModel
-from pydantic import Field
-from pydantic import field_validator
-
-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 GithubListIssueModel(BaseModel):
-    state: Literal["open", "closed", "all"] | None = Field('open', description="Issue state used in issue query filter")
-    assignee: str | None = Field("*", description="Assignee name used in issue query filter")
-    creator: str | None = Field(None, description="Creator name used in issue query filter")
-    mentioned: str | None = Field(None, description="Name of person mentioned in issue")
-    labels: list[str] | None = Field(None, description="A list of labels that are assigned to the issue")
-    since: str | None = Field(None, description="Only show results that were last updated after the given time.")
-
-    @classmethod
-    @field_validator('since', mode='before')
-    def validate_since(cls, v):
-        if v is None:
-            return v
-        try:
-            # Parse the string to a datetime object
-            parsed_date = datetime.strptime(v, "%Y-%m-%dT%H:%M:%SZ")
-            # Return the formatted string
-            return parsed_date.isoformat() + 'Z'
-        except ValueError as e:
-            raise ValueError("since must be in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ") from e
-
-
-class GithubListIssueModelList(BaseModel):
-    filter_params: GithubListIssueModel = Field(description=("A list of query params when fetching issues "
-                                                             "each of type GithubListIssueModel"))
-
-
-class GithubListIssueToolConfig(FunctionBaseConfig, name="github_list_issues_tool"):
-    """
-    Configuration for the GitHub List Issues Tool.
-    """
-    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=GithubListIssueToolConfig)
-async def list_github_issue_async(config: GithubListIssueToolConfig, builder: Builder):
-    """
-    Lists GitHub Issues based on various filter parameters
-
-    """
-    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_list_issues(filter_params) -> dict:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-
-            filter_params = filter_params.dict(exclude_unset=True)
-
-            # filter out None values that are explictly set in the request body.
-            filter_params = {k: v for k, v in filter_params.items() if v is not None}
-
-            response = await client.request("GET", url, params=filter_params, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_list_issues,
-                               description=(f"Lists GitHub issues based on filter "
-                                            f"params in the repo named {config.repo_name}"),
-                               input_schema=GithubListIssueModelList)
-
-
-class GithubGetIssueModel(BaseModel):
-    issue_number: str = Field(description="The issue number that needs to be fetched")
-
-
-class GithubGetIssueToolConfig(FunctionBaseConfig, name="github_get_issue_tool"):
-    """
-    Tool that fetches a particular issue in a GitHub repository asynchronously.
-    """
-    repo_name: str = "The repository name in the format 'owner/repo'"
-    timeout: int = 300
-
-
-@register_function(config_type=GithubGetIssueToolConfig)
-async def get_github_issue_async(config: GithubGetIssueToolConfig, builder: Builder):
-    """
-    Fetches a particular 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_get_issue(issue_number) -> list:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            # update the url with the issue number that needs to be updated
-            issue_url = os.path.join(url, issue_number)
-
-            response = await client.request("GET", issue_url, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_get_issue,
-                               description=(f"Fetches a particular GitHub issue "
-                                            f"in the repo named {config.repo_name}"),
-                               input_schema=GithubGetIssueModel)

nat/tool/github_tools/get_github_pr.py

@@ -1,256 +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 typing import Literal
-
-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 GithubListPullsModel(BaseModel):
-    state: Literal["open", "closed", "all"] | None = Field('open', description="Issue state used in issue query filter")
-    head: str | None = Field(None, description="Filters pulls by head user or head organization and branch name")
-    base: str | None = Field(None, description="Filters pull by branch name")
-
-
-class GithubListPullsModelList(BaseModel):
-    filter_params: GithubListPullsModel = Field(description=("A list of query params when fetching pull requests "
-                                                             "each of type GithubListPRModel"))
-
-
-class GithubListPullsToolConfig(FunctionBaseConfig, name="github_list_pulls_tool"):
-    """
-    Tool that lists GitHub Pull Requests based on various filter parameters
-    """
-    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=GithubListPullsToolConfig)
-async def list_github_pulls_async(config: GithubListPullsToolConfig, builder: Builder):
-    """
-    Lists GitHub Pull Requests based on various filter parameters
-
-    """
-    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}/pulls"
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_list_pulls(filter_params) -> dict:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-
-            filter_params = filter_params.dict(exclude_unset=True)
-
-            # filter out None values that are explictly set in the request body.
-            filter_params = {k: v for k, v in filter_params.items() if v is not None}
-
-            response = await client.request("GET", url, params=filter_params, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_list_pulls,
-                               description=(f"Lists GitHub PRs based on filter params "
-                                            f"in the repo named {config.repo_name}"),
-                               input_schema=GithubListPullsModelList)
-
-
-class GithubGetPullModel(BaseModel):
-    pull_number: str = Field(description="The number of the pull request that needs to be fetched")
-
-
-class GithubGetPullToolConfig(FunctionBaseConfig, name="github_get_pull_tool"):
-    """
-    Tool that fetches a particular pull request in a GitHub repository asynchronously.
-    """
-    repo_name: str = "The repository name in the format 'owner/repo'"
-    timeout: int = 300
-
-
-@register_function(config_type=GithubGetPullToolConfig)
-async def get_github_pull_async(config: GithubGetPullToolConfig, builder: Builder):
-    """
-    Fetches a particular pull request 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}/pulls"
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_get_pull(pull_number) -> list:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            # update the url with the pull number that needs to be updated
-            pull_url = os.path.join(url, pull_number)
-
-            response = await client.request("GET", pull_url, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_get_pull,
-                               description=(f"Fetches a particular GitHub pull request "
-                                            f"in the repo named {config.repo_name}"),
-                               input_schema=GithubGetPullModel)
-
-
-class GithubGetPullCommitsToolConfig(FunctionBaseConfig, name="github_get_pull_commits_tool"):
-    """
-    Configuration for the GitHub Get Pull Commits Tool.
-    """
-    repo_name: str = "The repository name in the format 'owner/repo'"
-    timeout: int = 300
-
-
-@register_function(config_type=GithubGetPullCommitsToolConfig)
-async def get_github_pull_commits_async(config: GithubGetPullCommitsToolConfig, builder: Builder):
-    """
-    Fetches the commits associated with a particular pull request 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}/pulls"
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_get_pull(pull_number) -> list:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            # update the url with the pull number that needs to be updated
-            pull_url = os.path.join(url, pull_number)
-            pull_commits_url = os.path.join(pull_url, "commits")
-
-            response = await client.request("GET", pull_commits_url, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_get_pull,
-                               description=("Fetches the commits for a particular GitHub pull request "
-                                            f" in the repo named {config.repo_name}"),
-                               input_schema=GithubGetPullModel)
-
-
-class GithubGetPullFilesToolConfig(FunctionBaseConfig, name="github_get_pull_files_tool"):
-    """
-    Configuration for the GitHub Get Pull Files Tool.
-    """
-    repo_name: str = "The repository name in the format 'owner/repo'"
-    timeout: int = 300
-
-
-@register_function(config_type=GithubGetPullFilesToolConfig)
-async def get_github_pull_files_async(config: GithubGetPullFilesToolConfig, builder: Builder):
-    """
-    Fetches the files associated with a particular pull request 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}/pulls"
-
-    # define the headers for the payload request
-    headers = {"Authorization": f"Bearer {github_pat}", "Accept": "application/vnd.github+json"}
-
-    async def _github_get_pull(pull_number) -> list:
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            # update the url with the pull number that needs to be updated
-            pull_url = os.path.join(url, pull_number)
-            pull_files_url = os.path.join(pull_url, "files")
-
-            response = await client.request("GET", pull_files_url, headers=headers)
-
-            # Raise an exception for HTTP errors
-            response.raise_for_status()
-
-            # Parse and return the response JSON
-            try:
-                result = response.json()
-
-            except ValueError as e:
-                raise ValueError("The API response is not valid JSON.") from e
-
-        return json.dumps(result)
-
-    yield FunctionInfo.from_fn(_github_get_pull,
-                               description=("Fetches the files for a particular GitHub pull request "
-                                            f" in the repo named {config.repo_name}"),
-                               input_schema=GithubGetPullModel)

nat/tool/github_tools/update_github_issue.py

@@ -1,100 +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 typing import Literal
-
-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 GithubUpdateIssueModel(BaseModel):
-    issue_number: str = Field(description="The issue number that will be updated")
-    title: str | None = Field(None, description="The title of the GitHub Issue")
-    body: str | None = Field(None, description="The body of the GitHub Issue")
-    state: Literal["open", "closed"] | None = Field(None, description="The new state of the issue")
-
-    state_reason: Literal["completed", "not_planned", "reopened", None] | None = Field(
-        None, description="The reason for changing the state of the issue")
-
-    labels: list[str] | None = Field(None, description="A list of labels to assign to the issue")
-    assignees: list[str] | None = Field(None, description="A list of assignees to assign to the issue")
-
-
-class GithubUpdateIssueModelList(BaseModel):
-    issues: list[GithubUpdateIssueModel] = Field(description=("A list of GitHub issues each "
-                                                              "of type GithubUpdateIssueModel"))
-
-
-class GithubUpdateIssueToolConfig(FunctionBaseConfig, name="github_update_issue_tool"):
-    """
-    Tool that updates an issue in a GitHub repository asynchronously.
-    """
-    repo_name: str = "The repository name in the format 'owner/repo'"
-    timeout: int = 300
-
-
-@register_function(config_type=GithubUpdateIssueToolConfig)
-async def update_github_issue_async(config: GithubUpdateIssueToolConfig, builder: Builder):
-    """
-    Updates 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_update_issue(issues) -> list:
-        results = []
-        async with httpx.AsyncClient(timeout=config.timeout) as client:
-            for issue in issues:
-                payload = issue.dict(exclude_unset=True)
-
-                # update the url with the issue number that needs to be updated
-                issue_number = payload.pop("issue_number")
-                issue_url = os.path.join(url, issue_number)
-
-                response = await client.request("PATCH", issue_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_update_issue,
-                               description=(f"Updates a GitHub issue in the "
-                                            f"repo named {config.repo_name}"),
-                               input_schema=GithubUpdateIssueModelList)