gpt-pr 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

gpt_pr/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version(__name__)

{gptpr → gpt_pr}/checkversion.py

@@ -2,35 +2,35 @@ import requests
 import os
 import json
 import tempfile
-from gptpr.version import __version__
+from gpt_pr import __version__
 from datetime import datetime, timedelta
 
-from gptpr import consolecolor as cc
+from gpt_pr import consolecolor as cc
 
 
-PACKAGE_NAME = 'gpt-pr'
-CACHE_FILE = os.path.join(os.path.expanduser("~"), '.gpt_pr_update_cache.json')
+PACKAGE_NAME = "gpt-pr"
+CACHE_FILE = os.path.join(os.path.expanduser("~"), ".gpt_pr_update_cache.json")
 CACHE_DURATION = timedelta(days=1)
 
 
 def cache_daily_version(func):
     def wrapper(*args, **kwargs):
         cache = load_cache()
-        last_checked = cache.get('last_checked')
+        last_checked = cache.get("last_checked")
 
         if last_checked:
             last_checked = datetime.fromisoformat(last_checked)
 
             if datetime.now() - last_checked < CACHE_DURATION:
                 # Use cached version info
-                latest_version = cache.get('latest_version')
+                latest_version = cache.get("latest_version")
                 if latest_version:
                     return latest_version
 
         latest_version = func(*args, **kwargs)
         cache = {
-            'last_checked': datetime.now().isoformat(),
-            'latest_version': latest_version
+            "last_checked": datetime.now().isoformat(),
+            "latest_version": latest_version,
         }
         save_cache(cache)
 
@@ -41,18 +41,18 @@ def cache_daily_version(func):
 
 def get_cache_file_path():
     temp_dir = tempfile.gettempdir()
-    return os.path.join(temp_dir, f'{PACKAGE_NAME}_update_cache.json')
+    return os.path.join(temp_dir, f"{PACKAGE_NAME}_update_cache.json")
 
 
 @cache_daily_version
 def get_latest_version():
-    url = f'https://pypi.org/pypi/{PACKAGE_NAME}/json'
+    url = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
 
     try:
         response = requests.get(url)
         response.raise_for_status()
         data = response.json()
-        return data['info']['version']
+        return data["info"]["version"]
     except requests.exceptions.RequestException as e:
         print(f"Error fetching latest version info: {e}")
         return None
@@ -61,7 +61,7 @@ def get_latest_version():
 def load_cache():
     cache_file = get_cache_file_path()
     if os.path.exists(cache_file):
-        with open(cache_file, 'r') as file:
+        with open(cache_file, "r") as file:
             return json.load(file)
 
     return {}
@@ -69,7 +69,7 @@ def load_cache():
 
 def save_cache(data):
     cache_file = get_cache_file_path()
-    with open(cache_file, 'w') as file:
+    with open(cache_file, "w") as file:
         file.write(json.dumps(data))
 
 
@@ -77,12 +77,15 @@ def check_for_updates():
     latest_version = get_latest_version()
 
     if latest_version and latest_version != __version__:
-        print('')
-        print(cc.yellow(
-            f'A new version of {PACKAGE_NAME} is available ({latest_version}). '
-            f'You are using version {__version__}. Please update by running'),
-            cc.green(f'pip install --upgrade {PACKAGE_NAME}.'))
-        print('')
+        print("")
+        print(
+            cc.yellow(
+                f"A new version of {PACKAGE_NAME} is available ({latest_version}). "
+                f"You are using version {__version__}. Please update by running"
+            ),
+            cc.green(f"pip install --upgrade {PACKAGE_NAME}."),
+        )
+        print("")
 
 
 if __name__ == "__main__":

gpt_pr/gh.py

@@ -0,0 +1,44 @@
+import os
+from github import Github
+from InquirerPy import inquirer
+from gpt_pr.config import config, config_command_example, CONFIG_README_SECTION
+
+
+def _get_gh_token():
+    gh_token = config.get_user_config("GH_TOKEN")
+    if not gh_token:
+        gh_token = os.environ.get("GH_TOKEN")
+
+    if not gh_token:
+        print(
+            'Please set "gh_token" config. Just run:',
+            config_command_example("gh_token", "[my gh token]"),
+            "more about at",
+            CONFIG_README_SECTION,
+        )
+        raise SystemExit(1)
+
+    return gh_token
+
+
+def create_pr(pr_data, yield_confirmation, gh=None):
+    if not gh:
+        gh = Github(_get_gh_token())
+
+    repo = gh.get_repo(f"{pr_data.branch_info.owner}/{pr_data.branch_info.repo}")
+
+    pr_confirmation = (
+        yield_confirmation
+        or inquirer.confirm(message="Create GitHub PR?", default=True).execute()
+    )
+
+    if pr_confirmation:
+        pr = repo.create_pull(
+            title=pr_data.title,
+            body=pr_data.create_body(),
+            head=pr_data.branch_info.branch,
+            base=pr_data.branch_info.base_branch,
+        )
+        print("Pull request created successfully: ", pr.html_url)
+    else:
+        print("cancelling...")

gpt_pr/gpt.py

@@ -0,0 +1,8 @@
+import tiktoken
+
+
+def num_tokens_from_string(string: str, encoding_name: str) -> int:
+    """Returns the number of tokens in a text string."""
+    encoding = tiktoken.get_encoding(encoding_name)
+    num_tokens = len(encoding.encode(string))
+    return num_tokens

gpt_pr/main.py

@@ -0,0 +1,117 @@
+import fire
+from InquirerPy import inquirer
+
+from gpt_pr.gitutil import get_branch_info
+from gpt_pr.gh import create_pr
+from gpt_pr.prdata import get_pr_data
+from gpt_pr import __version__
+from gpt_pr.config import config, config_command_example, CONFIG_README_SECTION
+from gpt_pr import consolecolor as cc
+from gpt_pr.checkversion import check_for_updates
+
+
+def run(base_branch="main", origin="origin", yield_confirmation=False, version=False):
+    """
+    Create Pull Requests from current branch with base branch (default 'main' branch)
+    """
+
+    if version:
+        print("Current version:", __version__)
+        return
+
+    branch_info = get_branch_info(base_branch, origin, yield_confirmation)
+
+    if not branch_info:
+        return
+
+    pr_data = None
+    generate_pr_data = True
+    while generate_pr_data:
+        pr_data = get_pr_data(branch_info)
+        print("")
+        print("#########################################")
+        print(pr_data.to_display())
+        print("#########################################")
+        print("")
+
+        if yield_confirmation:
+            break
+
+        generate_pr_data = not inquirer.confirm(
+            message="Create PR with this? If 'no', let's try again...", default=True
+        ).execute()
+
+        if generate_pr_data:
+            print("Generating another PR data...")
+
+    create_pr(pr_data, yield_confirmation)
+
+
+def set_config(name, value):
+    name = name.upper()
+    config.set_user_config(name, value)
+    config.persist()
+
+    print("Config value", cc.bold(name), "set to", cc.yellow(value))
+
+
+def get_config(name):
+    upper_name = name.upper()
+    print(
+        "Config value",
+        cc.bold(name),
+        "=",
+        cc.yellow(config.get_user_config(upper_name)),
+    )
+
+
+def reset_config(name):
+    upper_name = name.upper()
+    config.reset_user_config(upper_name)
+    print(
+        "Config value",
+        cc.bold(name),
+        "=",
+        cc.yellow(config.get_user_config(upper_name)),
+    )
+
+
+def print_config():
+    print("Config values at", cc.yellow(config.get_filepath()))
+    print("")
+    print(
+        "To set values, just run:",
+        cc.yellow(config_command_example("[config name]", "[value]")),
+    )
+    print("More about at", cc.yellow(CONFIG_README_SECTION))
+    print("")
+    current_section = None
+    for section, option, value in config.all_values():
+        if current_section != section:
+            print("")
+            current_section = section
+
+        print(f"[{cc.bold(section)}]", option, "=", cc.yellow(value))
+
+
+def main():
+    check_for_updates()
+
+    fire.Fire(run)
+
+
+def run_config():
+    check_for_updates()
+
+    fire.Fire(
+        {
+            "set": set_config,
+            "get": get_config,
+            "print": print_config,
+            "reset": reset_config,
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

gpt_pr/prdata.py

@@ -0,0 +1,238 @@
+from dataclasses import dataclass
+import json
+import os
+
+import tiktoken
+from openai import OpenAI
+
+from gpt_pr.gitutil import BranchInfo
+from gpt_pr.config import config, CONFIG_PROJECT_REPO_URL
+import gpt_pr.consolecolor as cc
+
+TOKENIZER_RATIO = 4
+
+DEFAULT_PR_TEMPLATE = (
+    "### Ref. [Link]\n\n## What was done?\n[Fill here]\n\n"
+    "## How was it done?\n[Fill here]\n\n"
+    "## How was it tested?\n[Fill here with test information from diff content or commits]"
+)
+
+
+def _get_pr_template():
+    pr_template = DEFAULT_PR_TEMPLATE
+
+    try:
+        github_dir = os.path.join(os.getcwd(), ".github")
+        github_files = os.listdir(github_dir)
+        pr_template_file = [
+            f for f in github_files if f.lower().startswith("pull_request_template")
+        ][0]
+        pr_template_file_path = os.path.join(github_dir, pr_template_file)
+
+        with open(pr_template_file_path, "r") as f:
+            local_pr_template = f.read()
+
+            if local_pr_template.strip() != "":
+                print("Found PR template at:", pr_template_file_path)
+                pr_template = local_pr_template
+            else:
+                print(
+                    "Empty PR template at:",
+                    pr_template_file_path,
+                    "using default template.",
+                )
+    except Exception:
+        print("PR template not found in .github dir. Using default template.")
+
+    return pr_template
+
+
+def _get_open_ai_key():
+    api_key = config.get_user_config("OPENAI_API_KEY")
+
+    if not api_key:
+        api_key = os.environ.get("OPENAI_API_KEY")
+
+    if not api_key:
+        print(
+            'Please set "openai_api_key" config, just run:',
+            cc.yellow("gpt-pr-config set openai_api_key [open ai key]"),
+        )
+        raise SystemExit(1)
+
+    return api_key
+
+
+def _count_tokens(text: str) -> int:
+    """Returns the number of tokens in a text string."""
+    openai_model = config.get_user_config("OPENAI_MODEL")
+    try:
+        encoding = tiktoken.encoding_for_model(openai_model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+
+    return len(encoding.encode(text))
+
+
+@dataclass
+class PrData:
+    branch_info: BranchInfo
+    title: str
+    body: str
+
+    def to_display(self):
+        return "\n".join(
+            [
+                f"{cc.bold('Repository')}: {cc.yellow(self.branch_info.owner)}/{cc.yellow(self.branch_info.repo)}",
+                f"{cc.bold('Title')}: {cc.yellow(self.title)}",
+                f"{cc.bold('Branch name')}: {cc.yellow(self.branch_info.branch)}",
+                f"{cc.bold('Base branch')}: {cc.yellow(self.branch_info.base_branch)}",
+                f"{cc.bold('PR Description')}:\n{self.create_body()}",
+            ]
+        )
+
+    def create_body(self):
+        body = self.body
+
+        if config.get_user_config("ADD_TOOL_SIGNATURE") == "true":
+            pr_signature = f"Generated by [GPT-PR]({CONFIG_PROJECT_REPO_URL})"
+            body += "\n\n---\n\n" + pr_signature
+
+        return body
+
+
+functions = [
+    {
+        "name": "create_pr",
+        "description": "Creates a Github Pull Request",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "description": "PR title, following angular commit convention",
+                },
+                "description": {"type": "string", "description": "PR description"},
+            },
+            "required": ["title", "description"],
+        },
+    }
+]
+
+
+def get_pr_data(branch_info):
+    client = OpenAI(api_key=_get_open_ai_key())
+
+    messages = _get_messages(branch_info)
+
+    openai_model = config.get_user_config("OPENAI_MODEL")
+    print("Using OpenAI model:", cc.yellow(openai_model))
+
+    chat_completion = client.chat.completions.create(
+        messages=messages,
+        model=openai_model,
+        functions=functions,
+        function_call={"name": "create_pr"},
+        temperature=0,
+        max_tokens=1000,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0,
+    )
+
+    arguments = _parse_json(chat_completion.choices[0].message.function_call.arguments)
+
+    return PrData(
+        branch_info=branch_info, title=arguments["title"], body=arguments["description"]
+    )
+
+
+def _get_messages(branch_info):
+    system_content = (
+        "You are a development assistant designed to craft Git pull requests "
+        "by incorporating information from main and secondary commits, diff changes, "
+        "and adhering to a provided PR template. Your output includes a complete PR "
+        "template with all necessary details and a suitable PR title. In the "
+        "PR description, detail the work accomplished, the methodology employed, "
+        "including testing procedures, and list significant changes in bullet points "
+        "if they are extensive. Avoid incorporating diff content directly into "
+        "the PR description."
+    )
+
+    messages = [
+        {"role": "system", "content": system_content},
+    ]
+
+    if len(branch_info.highlight_commits) > 0:
+        messages.append(
+            {
+                "role": "user",
+                "content": "main commits: " + "\n".join(branch_info.highlight_commits),
+            }
+        )
+        messages.append(
+            {
+                "role": "user",
+                "content": "secondary commits: " + "\n".join(branch_info.commits),
+            }
+        )
+    else:
+        messages.append(
+            {
+                "role": "user",
+                "content": "git commits: \n" + "\n".join(branch_info.commits),
+            }
+        )
+
+    messages.append({"role": "user", "content": "PR template:\n" + _get_pr_template()})
+
+    joined_messages = "\n".join([m["content"] for m in messages])
+    current_total_tokens = _count_tokens(joined_messages)
+
+    input_max_tokens = int(config.get_user_config("INPUT_MAX_TOKENS"))
+
+    if current_total_tokens > input_max_tokens:
+        exp_message = (
+            f"Length of {current_total_tokens} tokens for basic prompt "
+            f"(description and commits) is greater than max tokens {input_max_tokens} "
+            "(config 'input_max_tokens')"
+        )
+        raise Exception(exp_message)
+
+    total_tokens_with_diff = current_total_tokens + _count_tokens(branch_info.diff)
+    if total_tokens_with_diff > input_max_tokens:
+        print_msg = (
+            f"Length git changes with diff is too big (total is {total_tokens_with_diff}, "
+            f"'input_max_tokens' config is {input_max_tokens})."
+        )
+        print(print_msg, cc.red("Skipping changes diff content..."))
+    else:
+        messages.append(
+            {"role": "user", "content": "Diff changes:\n" + branch_info.diff}
+        )
+
+    return messages
+
+
+def _parse_json(content):
+    """
+    A bit of a hack to parse the json content from the chat completion
+    Sometimes it returns a string with invalid json content (line breaks) that
+    makes it hard to parse.
+    example:
+
+    content = '{\n"title": "feat(dependencies): pin dependencies versions",\n"description":
+                "### Ref. [Link]\n\n## What was done? ..."\n}'
+    """
+
+    try:
+        content = content.replace('{\n"title":', '{"title":')
+        content = content.replace(',\n"description":', ',"description":')
+        content = content.replace("\n}", "}")
+        content = content.replace("\n", "\\n")
+
+        return json.loads(content)
+    except Exception as e:
+        print("Error to decode message:", e)
+        print("Content:", content)
+        raise e

{gptpr → gpt_pr}/test_checkversion.py

@@ -4,39 +4,43 @@ import json
 from datetime import datetime
 from unittest.mock import patch, mock_open
 
-from gptpr.version import __version__
-from gptpr.checkversion import (get_latest_version, load_cache,
-                                save_cache, check_for_updates,
-                                CACHE_DURATION)
+from gpt_pr import __version__
+from gpt_pr.checkversion import (
+    get_latest_version,
+    load_cache,
+    save_cache,
+    check_for_updates,
+    CACHE_DURATION,
+)
 
 
 @pytest.fixture
 def mock_requests_get(mocker):
-    return mocker.patch('requests.get')
+    return mocker.patch("requests.get")
 
 
 @pytest.fixture
 def mock_os_path_exists(mocker):
-    return mocker.patch('os.path.exists')
+    return mocker.patch("os.path.exists")
 
 
 @pytest.fixture
 def mock_open_file(mocker):
-    return mocker.patch('builtins.open', mock_open())
+    return mocker.patch("builtins.open", mock_open())
 
 
 @pytest.fixture
 def mock_datetime(mocker):
-    return mocker.patch('gptpr.checkversion.datetime')
+    return mocker.patch("gpt_pr.checkversion.datetime")
 
 
 def test_get_latest_version(mock_requests_get, mock_os_path_exists):
     mock_os_path_exists.return_value = False
     mock_response = mock_requests_get.return_value
     mock_response.raise_for_status.return_value = None
-    mock_response.json.return_value = {'info': {'version': '2.0.0'}}
+    mock_response.json.return_value = {"info": {"version": "2.0.0"}}
 
-    assert get_latest_version() == '2.0.0'
+    assert get_latest_version() == "2.0.0"
 
 
 def test_get_latest_version_error(mock_requests_get, mock_os_path_exists):
@@ -48,13 +52,12 @@ def test_get_latest_version_error(mock_requests_get, mock_os_path_exists):
 
 def test_load_cache(mock_os_path_exists, mock_open_file):
     mock_os_path_exists.return_value = True
-    mock_open_file.return_value.read.return_value = json.dumps({
-        'last_checked': datetime.now().isoformat(),
-        'latest_version': '2.0.0'
-    })
+    mock_open_file.return_value.read.return_value = json.dumps(
+        {"last_checked": datetime.now().isoformat(), "latest_version": "2.0.0"}
+    )
 
     cache = load_cache()
-    assert cache['latest_version'] == '2.0.0'
+    assert cache["latest_version"] == "2.0.0"
 
 
 def test_load_cache_no_file(mock_os_path_exists):
@@ -65,47 +68,51 @@ def test_load_cache_no_file(mock_os_path_exists):
 
 
 def test_save_cache(mock_open_file):
-    data = {
-        'last_checked': datetime.now().isoformat(),
-        'latest_version': '2.0.0'
-    }
+    data = {"last_checked": datetime.now().isoformat(), "latest_version": "2.0.0"}
 
     save_cache(data)
     mock_open_file.return_value.write.assert_called_once_with(json.dumps(data))
 
 
-def test_check_for_updates_new_version(mocker, mock_datetime, mock_requests_get, mock_open_file):
+def test_check_for_updates_new_version(
+    mocker, mock_datetime, mock_requests_get, mock_open_file
+):
     # Set up mocks
     last_checked_str = (datetime(2024, 1, 1) - CACHE_DURATION).isoformat()
     mock_datetime.now.return_value = datetime(2024, 1, 2)
     mock_datetime.fromisoformat.return_value = datetime.fromisoformat(last_checked_str)
-    mock_open_file.return_value.read.return_value = json.dumps({
-        'last_checked': last_checked_str,
-        'latest_version': '1.0.0'
-    })
+    mock_open_file.return_value.read.return_value = json.dumps(
+        {"last_checked": last_checked_str, "latest_version": "1.0.0"}
+    )
     mock_requests_get.return_value.raise_for_status.return_value = None
-    mock_requests_get.return_value.json.return_value = {'info': {'version': '2.0.0'}}
+    mock_requests_get.return_value.json.return_value = {"info": {"version": "2.0.0"}}
 
     # Capture the print statements
-    with patch('builtins.print') as mocked_print:
+    with patch("builtins.print") as mocked_print:
         check_for_updates()
         assert mocked_print.call_count == 3
 
 
-def test_check_for_updates_no_new_version(mocker, mock_datetime, mock_requests_get, mock_open_file):
+def test_check_for_updates_no_new_version(
+    mocker, mock_datetime, mock_requests_get, mock_open_file
+):
     # Set up mocks
     last_checked_str = (datetime(2024, 1, 1) - CACHE_DURATION).isoformat()
     mock_datetime.now.return_value = datetime(2024, 1, 2)
     mock_datetime.fromisoformat.return_value = datetime.fromisoformat(last_checked_str)
-    mock_open_file.return_value.read.return_value = json.dumps({
-        'last_checked': (datetime(2024, 1, 1) - CACHE_DURATION).isoformat(),
-        'latest_version': __version__
-    })
+    mock_open_file.return_value.read.return_value = json.dumps(
+        {
+            "last_checked": (datetime(2024, 1, 1) - CACHE_DURATION).isoformat(),
+            "latest_version": __version__,
+        }
+    )
     mock_requests_get.return_value.raise_for_status.return_value = None
-    mock_requests_get.return_value.json.return_value = {'info': {'version': __version__}}
+    mock_requests_get.return_value.json.return_value = {
+        "info": {"version": __version__}
+    }
 
     # Capture the print statements
-    with patch('builtins.print') as mocked_print:
+    with patch("builtins.print") as mocked_print:
         check_for_updates()
         assert mocked_print.call_count == 0
 
@@ -115,12 +122,11 @@ def test_check_for_updates_cache_valid(mock_datetime, mock_open_file):
     last_checked_str = datetime(2024, 1, 2).isoformat()
     mock_datetime.now.return_value = datetime(2024, 1, 2)
     mock_datetime.fromisoformat.return_value = datetime.fromisoformat(last_checked_str)
-    mock_open_file.return_value.read.return_value = json.dumps({
-        'last_checked': last_checked_str,
-        'latest_version': __version__
-    })
+    mock_open_file.return_value.read.return_value = json.dumps(
+        {"last_checked": last_checked_str, "latest_version": __version__}
+    )
 
     # Capture the print statements
-    with patch('builtins.print') as mocked_print:
+    with patch("builtins.print") as mocked_print:
         check_for_updates()
         assert mocked_print.call_count == 0