gpt-pr 0.5.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

{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

{gptpr → gpt_pr}/test_config.py

@@ -3,12 +3,12 @@ import configparser
 
 from pytest import fixture
 
-from gptpr.config import Config
+from gpt_pr.config import Config
 
 
 @fixture
 def temp_config(tmpdir):
-    temp_dir = tmpdir.mkdir('config_dir')
+    temp_dir = tmpdir.mkdir("config_dir")
     config = Config(temp_dir)
     return config, temp_dir
 
@@ -29,10 +29,14 @@ def test_init_config_file(temp_config):
     # Check if the file exists
     assert os.path.isfile(os.path.join(str(temp_dir), config.config_filename))
 
-    _check_config(config, temp_dir, [
-        ('DEFAULT', 'OPENAI_MODEL', 'gpt-4o-mini'),
-        ('DEFAULT', 'OPENAI_API_KEY', ''),
-    ])
+    _check_config(
+        config,
+        temp_dir,
+        [
+            ("DEFAULT", "OPENAI_MODEL", "gpt-4o-mini"),
+            ("DEFAULT", "OPENAI_API_KEY", ""),
+        ],
+    )
 
 
 def test_new_default_value_should_be_added(temp_config):
@@ -42,43 +46,55 @@ def test_new_default_value_should_be_added(temp_config):
     new_config = Config(temp_dir)
 
     # Add a new default value
-    new_config.default_config['NEW_DEFAULT'] = 'new_default_value'
+    new_config.default_config["NEW_DEFAULT"] = "new_default_value"
     new_config.load()  # Should update config file...
 
-    _check_config(new_config, temp_dir, [
-        ('DEFAULT', 'NEW_DEFAULT', 'new_default_value'),
-    ])
+    _check_config(
+        new_config,
+        temp_dir,
+        [
+            ("DEFAULT", "NEW_DEFAULT", "new_default_value"),
+        ],
+    )
 
 
 def test_set_user_config(temp_config):
     config, temp_dir = temp_config
 
-    config.set_user_config('OPENAI_MODEL', 'gpt-3.5')
+    config.set_user_config("OPENAI_MODEL", "gpt-3.5")
     config.persist()
 
     # Read the configuration file and verify its contents
     config_to_test = configparser.ConfigParser()
     config_to_test.read(os.path.join(str(temp_dir), config.config_filename))
 
-    _check_config(config, temp_dir, [
-        ('user', 'OPENAI_MODEL', 'gpt-3.5'),
-        ('user', 'OPENAI_API_KEY', ''),
-    ])
+    _check_config(
+        config,
+        temp_dir,
+        [
+            ("user", "OPENAI_MODEL", "gpt-3.5"),
+            ("user", "OPENAI_API_KEY", ""),
+        ],
+    )
 
 
 def test_set_user_config_with_int_value(temp_config):
     config, temp_dir = temp_config
 
-    config.set_user_config('INPUT_MAX_TOKENS', 100)
+    config.set_user_config("INPUT_MAX_TOKENS", 100)
     config.persist()
 
     # Read the configuration file and verify its contents
     config_to_test = configparser.ConfigParser()
     config_to_test.read(os.path.join(str(temp_dir), config.config_filename))
 
-    _check_config(config, temp_dir, [
-        ('user', 'INPUT_MAX_TOKENS', '100'),
-    ])
+    _check_config(
+        config,
+        temp_dir,
+        [
+            ("user", "INPUT_MAX_TOKENS", "100"),
+        ],
+    )
 
 
 def test_all_values(temp_config):
@@ -87,30 +103,36 @@ def test_all_values(temp_config):
     all_values = config.all_values()
 
     assert all_values == [
-        ('DEFAULT', 'gh_token', ''),
-        ('DEFAULT', 'input_max_tokens', '15000'),
-        ('DEFAULT', 'openai_model', 'gpt-4o-mini'),
-        ('DEFAULT', 'openai_api_key', ''),
-        ('user', 'gh_token', ''),
-        ('user', 'input_max_tokens', '15000'),
-        ('user', 'openai_model', 'gpt-4o-mini'),
-        ('user', 'openai_api_key', ''),
+        ("DEFAULT", "add_tool_signature", "true"),
+        ("DEFAULT", "gh_token", ""),
+        ("DEFAULT", "input_max_tokens", "15000"),
+        ("DEFAULT", "openai_model", "gpt-4o-mini"),
+        ("DEFAULT", "openai_api_key", ""),
+        ("user", "add_tool_signature", "true"),
+        ("user", "gh_token", ""),
+        ("user", "input_max_tokens", "15000"),
+        ("user", "openai_model", "gpt-4o-mini"),
+        ("user", "openai_api_key", ""),
     ]
 
 
 def test_reset_user_config(temp_config):
     config, temp_dir = temp_config
 
-    config.set_user_config('OPENAI_MODEL', 'gpt-3.5')
+    config.set_user_config("OPENAI_MODEL", "gpt-3.5")
     config.persist()
 
-    config.reset_user_config('OPENAI_MODEL')
+    config.reset_user_config("OPENAI_MODEL")
 
     # Read the configuration file and verify its contents
     config_to_test = configparser.ConfigParser()
     config_to_test.read(os.path.join(str(temp_dir), config.config_filename))
 
-    _check_config(config, temp_dir, [
-        ('user', 'OPENAI_MODEL', 'gpt-4o-mini'),
-        ('user', 'OPENAI_API_KEY', ''),
-    ])
+    _check_config(
+        config,
+        temp_dir,
+        [
+            ("user", "OPENAI_MODEL", "gpt-4o-mini"),
+            ("user", "OPENAI_API_KEY", ""),
+        ],
+    )

gpt_pr/test_gh.py

@@ -0,0 +1,60 @@
+from types import SimpleNamespace
+import gpt_pr.gh as gh_module
+
+
+def test_create_pr_success(mocker, capsys):
+    fake_repo = mocker.Mock()
+    pr = SimpleNamespace(html_url="http://fake.url")
+    fake_repo.create_pull.return_value = pr
+
+    fake_gh = SimpleNamespace()
+    fake_gh.get_repo = lambda repo_name: fake_repo
+
+    branch_info = SimpleNamespace(
+        owner="owner", repo="repo", branch="feature-branch", base_branch="main"
+    )
+    pr_data = SimpleNamespace(
+        title="Test PR", branch_info=branch_info, create_body=lambda: "My body"
+    )
+
+    gh_module.create_pr(pr_data, yield_confirmation=True, gh=fake_gh)
+
+    fake_repo.create_pull.assert_called_once_with(
+        title="Test PR", body="My body", head="feature-branch", base="main"
+    )
+    captured = capsys.readouterr()
+    assert "Pull request created successfully" in captured.out
+    assert "http://fake.url" in captured.out
+
+
+def test_create_pr_cancel(mocker, capsys):
+    fake_repo = mocker.Mock()
+    fake_gh = SimpleNamespace()
+    fake_gh.get_repo = lambda repo_name: fake_repo
+
+    class FakePrompt:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def execute(self):
+            return False
+
+    mocker.patch.object(
+        gh_module.inquirer,
+        "confirm",
+        lambda *args, **kwargs: FakePrompt(*args, **kwargs),
+    )
+
+    branch_info = SimpleNamespace(
+        owner="owner", repo="repo", branch="branch", base_branch="base"
+    )
+    pr_data = SimpleNamespace(
+        title="Cancel PR", branch_info=branch_info, create_body=lambda: "Body"
+    )
+
+    gh_module.create_pr(pr_data, yield_confirmation=False, gh=fake_gh)
+
+    fake_repo.create_pull.assert_not_called()
+    captured = capsys.readouterr()
+
+    assert "cancelling..." in captured.out

gpt_pr/test_prdata.py

@@ -0,0 +1,17 @@
+from gpt_pr.prdata import _parse_json
+
+
+def test_parse_json():
+    content = (
+        '{\n"title": "feat(dependencies): pin dependencies '
+        'versions",\n"description": "### Ref. [Link]\n\n## What was done? ..."\n}'
+    )
+
+    expected = {
+        "title": "feat(dependencies): pin dependencies versions",
+        "description": "### Ref. [Link]\n\n## What was done? ...",
+    }
+
+    assert _parse_json(content) == expected, (
+        "The function did not return the expected output."
+    )

gpt_pr-0.7.2.dist-info/METADATA

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: gpt-pr
+Version: 0.7.2
+Summary: Automate your GitHub workflow with GPT-PR: an OpenAI powered library for streamlined PR generation.
+Author: alissonperez
+Author-email: 756802+alissonperez@users.noreply.github.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: fire (>=0.7.1,<0.8.0)
+Requires-Dist: gitpython (>=3.1.45,<4.0.0)
+Requires-Dist: inquirerpy (>=0.3.4,<0.4.0)
+Requires-Dist: prompt-toolkit (>=3.0.52,<4.0.0)
+Requires-Dist: pydantic-ai (>=1.14.0,<2.0.0)
+Requires-Dist: pygithub (>=2.8.1,<3.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: tiktoken (>=0.12.0,<0.13.0)
+Description-Content-Type: text/markdown
+
+# GPT-PR
+
+GPT-PR is an open-source command-line tool designed to streamline your GitHub workflow for opening PRs. Leveraging OpenAI's ChatGPT API, it automatically opens a GitHub Pull Request with a predefined description and title directly from your current project directory.
+
+[![asciicast](https://asciinema.org/a/u0PwZlNjAGZcdXPPrjf84wj2A.svg)](https://asciinema.org/a/u0PwZlNjAGZcdXPPrjf84wj2A)
+
+## Quick Start
+
+For a more detailed explanation, see [Installation](#installation) and [Configuration](#configuration).
+
+### 1. Installation
+
+```bash
+pip install -U gpt-pr
+```
+
+If you don't have the `pip` command available, follow [these instructions](https://pip.pypa.io/en/stable/installation/) to install it on different platforms.
+
+### 2. Fill OpenAI API Key
+
+1. Go to [OpenAI API Keys](https://platform.openai.com/api-keys) and generate a new key.
+2. Run the following command to fill your key in GPT-PR (it will be stored in `~/.gpt-pr.ini`):
+
+```bash
+gpt-pr-config set openai_api_key MY-API-KEY-VALUE
+```
+
+### 3. Generate a GitHub GH Token to Open PRs
+
+1. Go to [GitHub Settings](https://github.com/settings/tokens), choose `Generate new token (classic)`, and select all permissions under `repo` (full control of private repositories).
+2. Run the following command to fill your GH token (it will also be stored in `~/.gpt-pr.ini`):
+
+```bash
+gpt-pr-config set gh_token MY-GH-TOKEN-VALUE
+```
+
+### 4. Ready to NEVER WRITE A PR AGAIN
+
+1. Make your changes, commit them, and push to origin (important!).
+2. Run the following command in your project directory:
+
+```bash
+gpt-pr
+```
+
+3. Answer the questions. At the end, you'll receive the URL of a freshly opened PR.
+
+## Contributing and Feedback
+
+We welcome your contributions and feedback to help improve GPT-PR! Here’s how you can get involved:
+
+### Open Issues
+
+- **Feature Requests**: Have an idea for a new feature? We’d love to hear it! Open an issue to request new features or enhancements.
+- **Bug Reports**: Encountered a bug? Let us know by opening an issue with detailed information so we can fix it.
+- **General Feedback**: Any other suggestions or feedback? Feel free to share your thoughts.
+
+To open an issue, go to the [Issues](https://github.com/your-repo/gpt-pr/issues) section of our GitHub repository. Your contributions are very welcome and highly appreciated!
+
+More details about it at our [CONTRIBUTING](./CONTRIBUTING.md) guide.
+
+## Table of Contents
+
+- [Features](#features)
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Usage](#usage)
+- [How to Contribute](#how-to-contribute)
+- [Roadmap](#roadmap)
+
+## Features
+
+- Analyzes the diff changes of the current branch against the `main` branch.
+- Provides an option to exclude certain file changes from PR generation (for instance, you can ignore a `package.lock` file with 5k lines changed).
+- Incorporates commit messages into the process.
+
+## Prerequisites
+
+Before getting started, make sure you have the following installed:
+
+- Python 3.9 or higher
+- [Poetry](https://python-poetry.org/)
+
+## Installation
+
+You can install and use GPT-PR in one of two ways. Choose the option that best suits your needs.
+
+### Option 1: Using `pip install` (Recommended)
+
+1. Install OR Update the package:
+
+```bash
+pip install -U gpt-pr
+```
+
+2. Setup API keys for GitHub and OpenAI, take a look at [Configuration](#configuration).
+
+3. Inside the Git repository you are working on, ensure you have pushed your branch to origin, then run:
+
+```bash
+gpt-pr --help
+```
+
+### Option 2: Cloning the code (NOT recommended)
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/alissonperez/gpt-pr.git
+```
+
+2. Navigate to the project directory and install dependencies:
+
+```bash
+cd gpt-pr
+poetry install
+```
+
+After setting up API keys ([Configuration](#configuration)), you can use GPT-PR within any git project directory. Suppose you've cloned **this project** to `~/workplace/gpt-pr`, here's how you can use it:
+
+```bash
+poetry run python gpt_pr/main.py --help
+```
+
+## Configuration
+
+### See all configs available
+
+To print all default configs and what is being used, just run:
+
+```bash
+gpt-pr-config print
+```
+
+### Setting up GitHub Token (`GH_TOKEN`)
+
+GPT-PR tool will look for a `GH_TOKEN` in current shell env var OR in gpt-pr config file (at `~/.gpt-pr.ini`).
+
+To authenticate with GitHub, generate and export a GitHub Personal Access Token:
+
+1. Navigate to [GitHub's Personal Access Token page](https://github.com/settings/tokens).
+2. Click "Generate new token."
+3. Provide a description and select the required permissions `repo` for the token.
+4. Click "Generate token" at the bottom of the page.
+5. Copy the generated token.
+6. Set `gh_token` config running (supposing your gh token is `ghp_4Mb1QEr9gY5e8Lk3tN1KjPzX7W9z2V4HtJ2b`):
+
+```bash
+gpt-pr-config set gh_token ghp_4Mb1QEr9gY5e8Lk3tN1KjPzX7W9z2V4HtJ2b
+```
+
+Or just export it as an environment variable in your shell initializer:
+
+```bash
+export GH_TOKEN=your_generated_token_here
+```
+
+### Setting up OpenAI API Key (`OPENAI_API_KEY`)
+
+GPT-PR tool will look for a `OPENAI_API_KEY` env var in current shell OR in gpt-pr config file (at `~/.gpt-pr.ini`).
+
+This project needs to interact with the ChatGPT API to generate the pull request description. So, you need to generate and export an OpenAI API Key:
+
+1. Navigate to [OpenAI's API Key page](https://platform.openai.com/signup).
+2. If you don't have an account, sign up and log in.
+3. Go to the API Keys section and click "Create new key."
+4. Provide a description and click "Create."
+5. Copy the generated API key.
+6. Set `openai_api_key` config running (supposing your openai_api_key is `QEr9gY5e8Lk3tN1KjPzX7W9z2V4Ht`):
+
+```bash
+gpt-pr-config set openai_api_key QEr9gY5e8Lk3tN1KjPzX7W9z2V4Ht
+```
+
+Or just export it as an environment variable in your shell initializer:
+
+```bash
+export OPENAI_API_KEY=your_generated_api_key_here
+```
+
+### Setting Max Input LLM Tokens
+
+You can adjust the maximum number of input tokens allowed when calling the LLM model by modifying the corresponding setting.
+
+For example, to change the maximum to 20,000 tokens, use the following command:
+
+```bash
+gpt-pr-config set input_max_tokens 20000
+```
+
+### Change OpenAI model
+
+To change OpenAI model, just run:
+
+```bash
+gpt-pr-config set openai_model gpt-4o-mini
+```
+
+> Obs.: `gpt-4o-mini` already is the default model of the project
+
+To see a full list of available models, access [OpenAI Models Documentation](https://platform.openai.com/docs/models)
+
+### GPT-PR Library Signature in PRs
+
+To help other developers recognize and understand the use of the GPT-PR library in generating pull requests, we have included an optional signature feature. By default, this feature is enabled and appends the text "Generated by GPT-PR" at the end of each pull request. This transparency fosters better collaboration and awareness among team members about the tools being utilized in the development process.
+
+If you prefer to disable this feature, simply run the following command:
+
+```bash
+gpt-pr-config set add_tool_signature false
+```
+
+### Reset config
+
+To reset any config to default value, just run:
+
+```bash
+gpt-pr-config reset config_name
+```
+
+Example:
+
+```bash
+gpt-pr-config reset openai_model
+```
+
+## Usage
+
+### Generating Github Pull Requests
+
+To create a Pull request from your current branch commits to merge with `main` branch, just run:
+
+```
+gpt-pr
+```
+
+If you would like to compare with other base branch that is not `main`, just use `-b` param:
+
+```
+gpt-pr -b my-other-branch
+```
+
+### Usage help
+
+To show help commands:
+
+```
+gpt-pr -h
+```
+
+Output:
+![image](https://github.com/alissonperez/gpt-pr/assets/756802/cc6c0ca4-5759-44ce-ad35-e4e7305b3875)
+
+## Roadmap
+
+- [x] Improve execution method, possibly through a shell script or at least an alias in bash rc files.
+  - Change to use with pip installation and console_scripts entry point.
+- [x] Fetch GitHub PR templates from the current project.
+- [ ] Add configuration to set which LLM and model should be used (OpenAI GPT, Mistral, etc...)
+- [ ] Add unit tests.
+