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

gpt_pr/__init__.py

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

gpt_pr/checkversion.py

@@ -0,0 +1,93 @@
+import requests
+import os
+import json
+import tempfile
+from gpt_pr import __version__
+from datetime import datetime, timedelta
+
+from gpt_pr import consolecolor as cc
+
+
+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")
+
+        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")
+                if latest_version:
+                    return latest_version
+
+        latest_version = func(*args, **kwargs)
+        cache = {
+            "last_checked": datetime.now().isoformat(),
+            "latest_version": latest_version,
+        }
+        save_cache(cache)
+
+        return latest_version
+
+    return wrapper
+
+
+def get_cache_file_path():
+    temp_dir = tempfile.gettempdir()
+    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"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        data = response.json()
+        return data["info"]["version"]
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching latest version info: {e}")
+        return None
+
+
+def load_cache():
+    cache_file = get_cache_file_path()
+    if os.path.exists(cache_file):
+        with open(cache_file, "r") as file:
+            return json.load(file)
+
+    return {}
+
+
+def save_cache(data):
+    cache_file = get_cache_file_path()
+    with open(cache_file, "w") as file:
+        file.write(json.dumps(data))
+
+
+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("")
+
+
+if __name__ == "__main__":
+    check_for_updates()
+    # Your CLI code here

gpt_pr/config.py

@@ -0,0 +1,104 @@
+from copy import deepcopy
+import configparser
+import os
+
+
+def config_command_example(name, value_sample):
+    return f'gpt-pr-config set {name} {value_sample}'
+
+
+CONFIG_PROJECT_REPO_URL = 'https://github.com/alissonperez/gpt-pr'
+CONFIG_README_SECTION = f'{CONFIG_PROJECT_REPO_URL}?tab=readme-ov-file#configuration'
+
+
+class Config:
+
+    config_filename = '.gpt-pr.ini'
+
+    _default_config = {
+        # Amenities
+        'ADD_TOOL_SIGNATURE': 'true',  # Add GPT-PR signature to PRs
+
+        # Github
+        'GH_TOKEN': '',
+
+        # LLM input MAX Tokens
+        'INPUT_MAX_TOKENS': '15000',
+
+        # Open AI info
+        'OPENAI_MODEL': 'gpt-4o-mini',
+        'OPENAI_API_KEY': '',
+    }
+
+    def __init__(self, config_dir=None):
+        self.default_config = deepcopy(self._default_config)
+        self._config_dir = config_dir or os.path.expanduser('~')
+        self._config = configparser.ConfigParser()
+        self._initialized = False
+
+    def load(self):
+        if self._initialized:
+            return
+
+        config_file_path = self.get_filepath()
+
+        if os.path.exists(config_file_path):
+            self._config.read(config_file_path)
+            self._ensure_default_values()
+        else:
+            self._config['user'] = {}
+            self._config['DEFAULT'] = deepcopy(self.default_config)
+            self.persist()
+
+        self._initialized = True
+
+    def _ensure_default_values(self):
+        added = False
+        for key, value in self.default_config.items():
+            if key not in self._config['DEFAULT']:
+                self._config['DEFAULT'][key] = value
+                added = True
+
+        if added:
+            self.persist()
+
+    def persist(self):
+        config_file_path = self.get_filepath()
+
+        with open(config_file_path, 'w') as configfile:
+            self._config.write(configfile)
+
+    def get_filepath(self):
+        return os.path.join(self._config_dir, self.config_filename)
+
+    def set_user_config(self, name, value):
+        self.load()
+        self._config['user'][name] = str(value)
+
+    def reset_user_config(self, name):
+        self.load()
+        self._config['user'][name] = self.default_config[name]
+        self.persist()
+
+    def get_user_config(self, name):
+        self.load()
+        return self._config['user'][name]
+
+    def all_values(self):
+        self.load()
+
+        # iterate over all sections and values and return them in a list
+        result = []
+
+        # add default section
+        for option in self._config['DEFAULT']:
+            result.append(('DEFAULT', option, self._config['DEFAULT'][option]))
+
+        for section in self._config.sections():
+            for option in self._config[section]:
+                result.append((section, option, self._config[section][option]))
+
+        return result
+
+
+config = Config()

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

{gptpr → gpt_pr}/gitutil.py

@@ -32,12 +32,9 @@ class FileChange:
         return f'{self.file_path} (+{(self.lines_added)} -{self.lines_removed})'
 
 
-def get_branch_info(base_branch, yield_confirmation):
-    # Get current directory
-    current_dir = os.getcwd()
-
-    # Instantiate the repository
-    repo = Repo(current_dir)
+def get_branch_info(base_branch, origin, yield_confirmation):
+    git_dir = fetch_nearest_git_dir(os.getcwd())
+    repo = Repo(git_dir)
 
     # Check that the repository loaded correctly
     if not repo.bare:
@@ -57,7 +54,7 @@ def get_branch_info(base_branch, yield_confirmation):
     if not _branch_exists(repo, base_branch):
         raise Exception(f'Base branch {base_branch} does not exist.')
 
-    owner, repo_name = _get_remote_info(repo)
+    owner, repo_name = _get_remote_info(repo, origin)
 
     commits = _get_diff_messages_against_base_branch(repo, current_branch.name, base_branch)
     commits = _get_valid_commits(commits, yield_confirmation)
@@ -79,6 +76,18 @@ def get_branch_info(base_branch, yield_confirmation):
     )
 
 
+def fetch_nearest_git_dir(current_dir):
+    # Goes upwards until it finds a .git directory
+    path = os.path.abspath(current_dir)
+    while True:
+        if os.path.isdir(os.path.join(path, '.git')):
+            return path
+        parent = os.path.dirname(path)
+        if parent == path:  # Reached root
+            raise FileNotFoundError(f"Could not find a .git directory in or above '{current_dir}'")
+        path = parent
+
+
 def _branch_exists(repo, branch_name):
     if branch_name in repo.branches:
         return True
@@ -125,9 +134,9 @@ def _get_highlight_commits(commits, yield_confirmation):
     return highlight_commits
 
 
-def _get_remote_info(repo):
+def _get_remote_info(repo, origin):
     for remote in repo.remotes:
-        if remote.name != 'origin':
+        if remote.name != origin:
             continue
 
         remote_urls_joined = ','.join([str(url) for url in remote.urls])
@@ -137,7 +146,7 @@ def _get_remote_info(repo):
         for url in remote.urls:
             return _extract_owner_and_repo(url)
 
-    raise Exception('Could not find origin remote.')
+    raise Exception(f'Could not find \'{origin}\' remote.')
 
 
 def _extract_owner_and_repo(repo_url):
@@ -183,10 +192,15 @@ def _get_stats(repo, base_branch, branch):
             continue
 
         line = line.split('\t')
+
+        # Binary files will not have stats (just "-")
+        added = int(line[0]) if line[0] and line[0].isdigit() else 0
+        removed = int(line[1]) if line[1] and line[1].isdigit() else 0
+
         files_changed.append(FileChange(
             file_path=line[2],
-            lines_added=int(line[0]),
-            lines_removed=int(line[1])
+            lines_added=added,
+            lines_removed=removed
         ))
 
     return files_changed

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,217 @@
+from dataclasses import dataclass
+import json
+import os
+
+import tiktoken
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+from gpt_pr.gitutil import BranchInfo, fetch_nearest_git_dir
+from gpt_pr.config import config, CONFIG_PROJECT_REPO_URL
+import gpt_pr.consolecolor as cc
+
+
+class PRTemplateModel(BaseModel):
+    title: str = Field(description="Title of the pull request")
+    description: str = Field(description="Description of the pull request")
+
+
+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]"
+)
+
+SYSTEM_PROMPT = '''You are a generator of pull request data based on diff changes.
+
+By analyzing the diff content and commit messages between two branches, you must strictly adhere to
+the provided Pull Request template and produce a complete, ready-to-use PR output.
+
+Your response must include:
+- A clear and concise PR title.
+- A PR description that:
+  - Details the work accomplished.
+  - Describes the methodology used, including testing procedures.
+  - Lists significant changes in bullet points.
+
+Rules:
+- Do not include raw diff content of any size.
+- Do not add any explanations, suggestions, or messages directed to the user.
+
+Pull Request Template:
+---
+{pr_template}
+---
+'''
+
+
+def _get_pr_template():
+    pr_template = DEFAULT_PR_TEMPLATE
+    git_dir = fetch_nearest_git_dir(os.getcwd())
+
+    try:
+        github_dir = os.path.join(git_dir, ".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
+
+
+def get_pr_data(branch_info):
+    system_prompt, messages = _get_messages(branch_info)
+
+    openai_model = config.get_user_config("OPENAI_MODEL")
+    model = OpenAIChatModel(openai_model, provider=OpenAIProvider(api_key=_get_open_ai_key()))
+
+    support_agent = Agent(
+        model=model,  # TODO: make configurable for other providers
+        output_type=PRTemplateModel,
+        instructions=system_prompt,
+    )
+
+    print("Generating changes description using OpenAI model", cc.yellow(openai_model), '. This may take time...')
+
+    result = support_agent.run_sync(messages)
+    output = result.output
+
+    return PrData(
+        branch_info=branch_info, title=output.title.strip(), body=output.description.strip()
+    )
+
+
+def _get_messages(branch_info):
+    system_prompt = SYSTEM_PROMPT.format(pr_template=_get_pr_template())
+
+    messages = []
+
+    if len(branch_info.highlight_commits) > 0:
+        messages.append("main commits:\n" + "\n".join(branch_info.highlight_commits))
+        messages.append("---")
+        messages.append("secondary commits:\n" + "\n".join(branch_info.commits))
+    else:
+        messages.append("git commits:\n" + "\n".join(branch_info.commits))
+
+    joined_messages = "\n".join([m for m in messages])
+    current_total_tokens = _count_tokens(joined_messages) + _count_tokens(SYSTEM_PROMPT)
+
+    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("Diff changes:\n" + branch_info.diff)
+
+    return system_prompt, '\n'.join(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