tgit 0.10.0__tar.gz → 0.10.2__tar.gz

{tgit-0.10.0 → tgit-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: tgit
-Version: 0.10.0
+Version: 0.10.2
 Summary: Tool for Git Interaction Temptation (tgit): An elegant CLI tool that simplifies and streamlines your Git workflow, making version control a breeze.
 Author-email: Jannchie <jannchie@gmail.com>
 License-Expression: MIT
@@ -15,6 +15,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: gitpython>=3.1.43
 Requires-Dist: inquirer>=3.4.0
+Requires-Dist: jinja2>=3.1.4
 Requires-Dist: openai>=1.52.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.2

{tgit-0.10.0 → tgit-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tgit"
-version = "0.10.0"
+version = "0.10.2"
 description = "Tool for Git Interaction Temptation (tgit): An elegant CLI tool that simplifies and streamlines your Git workflow, making version control a breeze."
 authors = [{ name = "Jannchie", email = "jannchie@gmail.com" }]
 dependencies = [
@@ -9,6 +9,7 @@ dependencies = [
     "inquirer>=3.4.0",
     "gitpython>=3.1.43",
     "openai>=1.52.0",
+    "jinja2>=3.1.4",
 ]
 readme = { content-type = "text/markdown", file = "README.md" }
 requires-python = ">= 3.11"
@@ -28,10 +29,6 @@ license = "MIT"
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
-[tool.rye]
-managed = true
-dev-dependencies = ["black>=24.10.0", "isort>=5.13.2"]
-
 [tool.black]
 line-length = 160
 
@@ -43,3 +40,19 @@ packages = ["tgit"]
 
 [project.scripts]
 tgit = "tgit:cli.main"
+
+[tool.ruff]
+line-length = 140
+select = ["ALL"]
+
+ignore = [
+    "PGH",
+    "RUF003",
+    "BLE001",
+    "ERA001",
+    "FIX002",
+    "TD002",
+    "TD003",
+    "D",
+    "TRY300",
+]

{tgit-0.10.0 → tgit-0.10.2}/tgit/add.py

@@ -1,13 +1,15 @@
+import argparse
+
 from tgit.utils import simple_run_command
 
 
-def define_add_parser(subparsers):
+def define_add_parser(subparsers: argparse._SubParsersAction) -> None:
     parser_add = subparsers.add_parser("add", help="same as git add")
     parser_add.add_argument("files", help="files to add", nargs="*")
     parser_add.set_defaults(func=handle_add)
 
 
-def handle_add(args):
+def handle_add(args: argparse.Namespace) -> None:
     files = " ".join(args.files)
     command = f"git add {files}"
     simple_run_command(command)

{tgit-0.10.0 → tgit-0.10.2}/tgit/changelog.py

@@ -1,23 +1,27 @@
+import logging
 import re
 import warnings
+from argparse import _SubParsersAction
 from collections import defaultdict
 from dataclasses import dataclass
+from pathlib import Path
 
 import git
 
+logger = logging.getLogger("tgit")
 
-def get_latest_git_tag(repo: git.Repo):
+
+def get_latest_git_tag(repo: git.Repo) -> str:
     return get_tag_by_idx(repo, -1)
 
 
-def get_tag_by_idx(repo: git.Repo, idx: int):
+def get_tag_by_idx(repo: git.Repo, idx: int) -> str:
     try:
         if tags := sorted(repo.tags, key=lambda t: t.commit.committed_datetime):
             return tags[idx].name
-        else:
-            return None
-    except Exception as e:
-        print(f"Error: {e}")
+        return None
+    except Exception:
+        logger.exception("Can't find tag by index %s", idx)
         return None
 
 
@@ -28,15 +32,15 @@ def get_first_commit_hash(repo: git.Repo) -> str:
     )
 
 
-def get_commit_hash_from_tag(repo: git.Repo, tag):
+def get_commit_hash_from_tag(repo: git.Repo, tag: str) -> str:
     try:
         return repo.tags[tag].commit.hexsha
-    except Exception as e:
-        print(f"Error: {e}")
+    except Exception:
+        logger.exception("Can't find tag %s", tag)
         return None
 
 
-def define_changelog_parser(subparsers):
+def define_changelog_parser(subparsers: _SubParsersAction) -> None:
     parser_changelog = subparsers.add_parser("changelog", help="generate changelogs")
     parser_changelog.add_argument("-f", "--from", help="From hash/tag", type=str, dest="from_raw")
     parser_changelog.add_argument("-t", "--to", help="To hash/tag", type=str, dest="to_raw")
@@ -64,29 +68,29 @@ class ChangelogArgs:
     output: str
 
 
-def get_simple_hash(repo: git.Repo, hash, length=7):
+def get_simple_hash(repo: git.Repo, git_hash: str, length: int = 7) -> str:
     try:
-        return repo.git.rev_parse(hash, short=length)
-    except Exception as e:
-        print(f"Error: {e}")
+        return repo.git.rev_parse(git_hash, short=length)
+    except Exception:
+        logger.exception("Can't find hash %s", git_hash)
         return None
 
 
-def ref_to_hash(repo: git.Repo, ref: str, length=7):
+def ref_to_hash(repo: git.Repo, ref: str, length: int = 7) -> str:
     try:
         return repo.git.rev_parse(ref, short=length)
-    except Exception as e:
-        print(f"Error: {e}")
+    except Exception:
+        logger.exception("Can't find ref %s", ref)
         return None
 
 
 commit_pattern = re.compile(
-    r"(?P<emoji>:.+:|(\uD83C[\uDF00-\uDFFF])|(\uD83D[\uDC00-\uDE4F\uDE80-\uDEFF])|[\u2600-\u2B55])?( *)?(?P<type>[a-z]+)(\((?P<scope>.+?)\))?(?P<breaking>!)?: (?P<description>.+)",
+    r"(?P<emoji>:.+:|(\uD83C[\uDF00-\uDFFF])|(\uD83D[\uDC00-\uDE4F\uDE80-\uDEFF])|[\u2600-\u2B55])?( *)?(?P<type>[a-z]+)(\((?P<scope>.+?)\))?(?P<breaking>!)?: (?P<description>.+)",  # noqa: E501
     re.IGNORECASE,
 )
 
 
-def resolve_from_ref(repo, from_raw):
+def resolve_from_ref(repo: git.Repo, from_raw: str) -> str:
     if from_raw is not None:
         return from_raw
     last_tag = get_latest_git_tag(repo)
@@ -98,18 +102,18 @@ class Author:
     name: str
     email: str
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.name} <{self.email}>"
 
 
 class TGITCommit:
-    def __init__(self, repo: git.Repo, commit: git.Commit, message_dict: dict):
+    def __init__(self, repo: git.Repo, commit: git.Commit, message_dict: dict) -> None:
         commit_date = commit.committed_datetime
 
         co_author_raws = [line for line in commit.message.split("\n") if line.lower().startswith("co-authored-by:")]
         co_author_pattern = re.compile(r"Co-authored-by: (?P<name>.+?) <(?P<email>.+?)>", re.IGNORECASE)
         co_authors = [co_author_pattern.match(co_author).groupdict() for co_author in co_author_raws]
-        authors = [{"name": commit.author.name, "email": commit.author.email}] + co_authors
+        authors = [{"name": commit.author.name, "email": commit.author.email}, *co_authors]
         self.authors: list[Author] = [Author(**kwargs) for kwargs in authors]
         self.date = commit_date
         self.emoji = message_dict.get("emoji")
@@ -131,14 +135,14 @@ class TGITCommit:
         )
 
 
-def format_names(names):
+def format_names(names: list[str]) -> str:
     if not names:
         return ""
 
     if len(names) == 1:
         return f"By {names[0]}"
 
-    if len(names) == 2:
+    if len(names) == 2:  # noqa: PLR2004
         return f"By {names[0]} and {names[1]}"
 
     formatted_names = ", ".join(names[:-1])
@@ -147,7 +151,7 @@ def format_names(names):
     return f"By {formatted_names}"
 
 
-def get_remote_uri(url: str):
+def get_remote_uri(url: str) -> str:
     # SSH URL regex, with groups for domain, namespace and repo name
     ssh_pattern = re.compile(r"git@([\w\.]+):(.+)/(.+)\.git")
     # HTTPS URL regex, with groups for domain, namespace and repo name
@@ -184,7 +188,7 @@ def group_commits_by_type(commits: list[TGITCommit]) -> dict[str, list[TGITCommi
     return commits_by_type
 
 
-def generate_changelog(commits_by_type: dict[str, list[TGITCommit]], from_ref: str, to_ref: str, remote_uri: str = None) -> str:
+def generate_changelog(commits_by_type: dict[str, list[TGITCommit]], from_ref: str, to_ref: str, remote_uri: str | None = None) -> str:
     order = ["breaking", "feat", "fix", "refactor", "perf", "style", "docs", "chore"]
     names = [
         ":rocket: Breaking Changes",
@@ -203,7 +207,7 @@ def generate_changelog(commits_by_type: dict[str, list[TGITCommit]], from_ref: s
     else:
         out_str += f"{from_ref}...{to_ref}\n\n"
 
-    def get_hash_link(commit: TGITCommit):
+    def get_hash_link(commit: TGITCommit) -> str:
         if remote_uri:
             return f"[{commit.hash}](https://{remote_uri}/commit/{commit.hash})"
         return commit.hash
@@ -215,7 +219,6 @@ def generate_changelog(commits_by_type: dict[str, list[TGITCommit]], from_ref: s
             # Sort commits by scope, if scope is None, put it to last
             commits.sort(key=lambda c: c.scope or "zzzzz")
             for commit in commits:
-
                 authors_str = format_names([f"[{a.name}](mailto:{a.email})" for a in commit.authors])
                 if commit.scope:
                     line = f"- **{commit.scope}**: {commit.description} - {authors_str} in {get_hash_link(commit)}\n"
@@ -226,39 +229,39 @@ def generate_changelog(commits_by_type: dict[str, list[TGITCommit]], from_ref: s
     return out_str
 
 
-def handle_changelog(args: ChangelogArgs):
+def handle_changelog(args: ChangelogArgs) -> None:
     repo = git.Repo(args.path)
 
     if args.output:
-        output_file = open(args.output, "w")
-        # 获取所有 tags
-        tags = repo.tags
-        # 获取第一个 commit
-        first_commit = get_first_commit_hash(repo)
-        points = [first_commit] + [tag.name for tag in tags]
-        points.reverse()
-        changelogs = ""
-        for i in range(len(points) - 1):
-            to_ref = points[i]
-            from_ref = points[i + 1]
-            changelog = get_changelog_by_range(repo, from_ref, to_ref)
-            changelogs += changelog
-        output_file.write(changelogs.strip("\n") + "\n")
+        with Path(args.output).open("w") as output_file:
+            # 获取所有 tags
+            tags = repo.tags
+            # 获取第一个 commit
+            first_commit = get_first_commit_hash(repo)
+            points = [first_commit] + [tag.name for tag in tags]
+            points.reverse()
+            changelogs = ""
+            for i in range(len(points) - 1):
+                to_ref = points[i]
+                from_ref = points[i + 1]
+                changelog = get_changelog_by_range(repo, from_ref, to_ref)
+                changelogs += changelog
+            output_file.write(changelogs.strip("\n") + "\n")
     from_raw = args.from_raw
     to_raw = args.to_raw
 
     from_ref, to_ref = get_git_commits_range(repo, from_raw, to_raw)
     changelog = get_changelog_by_range(repo, from_ref, to_ref)
-    print()
-    print(changelog)
+    print()  # noqa: T201
+    print(changelog)  # noqa: T201
 
 
-def get_changelog_by_range(repo: git.Repo, from_ref: str, to_ref: str):
+def get_changelog_by_range(repo: git.Repo, from_ref: str, to_ref: str) -> str:
     try:
         origin_url = repo.remote().url
         remote_uri = get_remote_uri(origin_url)
     except ValueError:
-        warnings.warn("Origin not found, some of the link generation functions could not be enabled.")
+        warnings.warn("Origin not found, some of the link generation functions could not be enabled.", stacklevel=2)
         remote_uri = None
 
     tgit_commits = get_commits(repo, from_ref, to_ref)
@@ -266,7 +269,7 @@ def get_changelog_by_range(repo: git.Repo, from_ref: str, to_ref: str):
     return generate_changelog(commits_by_type, from_ref, to_ref, remote_uri)
 
 
-def get_git_commits_range(repo: git.Repo, from_raw: str, to_raw: str):
+def get_git_commits_range(repo: git.Repo, from_raw: str, to_raw: str) -> tuple[str, str]:
     from_ref = resolve_from_ref(repo, from_raw)
     to_ref = "HEAD" if to_raw is None else to_raw
     if to_ref == "HEAD":

{tgit-0.10.0 → tgit-0.10.2}/tgit/cli.py

@@ -13,7 +13,7 @@ from tgit.version import define_version_parser
 rich.traceback.install()
 
 
-def main():
+def main() -> None:
     parser = argparse.ArgumentParser(
         description="TGIT cli",
         prog="tgit",
@@ -31,7 +31,7 @@ def main():
     handle(parser, args)
 
 
-def handle(parser, args):
+def handle(parser: argparse.ArgumentParser, args: argparse.Namespace) -> None:
     if hasattr(args, "func"):
         args.func(args)
     elif args.version:

{tgit-0.10.0 → tgit-0.10.2}/tgit/commit.py

@@ -1,21 +1,27 @@
 import argparse
+import importlib.resources
 import itertools
-import os
 from dataclasses import dataclass
-from typing import Optional
+from pathlib import Path
 
 import git
+from jinja2 import Environment, FileSystemLoader
 from openai import AuthenticationError, OpenAI
 from pydantic import BaseModel
-from rich import print
+from rich import print  # noqa: A004
 
 from tgit.settings import settings
 from tgit.utils import get_commit_command, run_command, type_emojis
 
-commit_type = ["feat", "fix", "chore", "docs", "style", "refactor", "perf", "wip"]
+with importlib.resources.path("tgit", "prompts") as prompt_path:
+    env = Environment(loader=FileSystemLoader(prompt_path), autoescape=True)
 
+commit_types = ["feat", "fix", "chore", "docs", "style", "refactor", "perf", "wip"]
+commit_file = "commit.txt"
+commit_prompt_template = env.get_template("commit.txt")
 
-def define_commit_parser(subparsers: argparse._SubParsersAction):
+
+def define_commit_parser(subparsers: argparse._SubParsersAction) -> None:
     commit_type = ["feat", "fix", "chore", "docs", "style", "refactor", "perf"]
     commit_settings = settings.get("commit", {})
     types_settings = commit_settings.get("types", [])
@@ -26,7 +32,7 @@ def define_commit_parser(subparsers: argparse._SubParsersAction):
     parser_commit = subparsers.add_parser("commit", help="commit changes following the conventional commit format")
     parser_commit.add_argument(
         "message",
-        help="commit message, the first word should be the type, if the message is more than two parts, the second part should be the scope",
+        help="the first word should be the type, if the message is more than two parts, the second part should be the scope",
         nargs="*",
     )
     parser_commit.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
@@ -46,35 +52,29 @@ class CommitArgs:
 
 class CommitData(BaseModel):
     type: str
-    scope: Optional[str]
+    scope: str | None
     msg: str
     is_breaking: bool
 
 
 def get_ai_command() -> str | None:
     client = OpenAI()
-    # 获取用户执行该脚本所在的目录
-    current_dir = os.getcwd()
+    current_dir = Path.cwd()
     try:
         repo = git.Repo(current_dir, search_parent_directories=True)
     except git.InvalidGitRepositoryError:
         print("[yellow]Not a git repository[/yellow]")
-        return
+        return None
     diff = repo.git.diff("--cached")
     if not diff:
         print("[yellow]No changes to commit, please add some changes before using AI[/yellow]")
-        return
-    types = "|".join(commit_type)
+        return None
     try:
         chat_completion = client.beta.chat.completions.parse(
             messages=[
                 {
                     "role": "system",
-                    "content": "You are a git bot. You should read the diff and suggest a commit message. "
-                    + "Only if the changes are not compatible with previous versions (change the API, break the build, etc.), you should suggest a breaking change. "
-                    + f"The type should be one of {types}. The message should in all lowercase. And it shoud be short, in just few words. "
-                    + "The scope should be short, it is better to be a single word. "
-                    + "The message should cover all the changes in the diff. It should be in present tense. If the change has many parts, you can && to separate them, and you should also shorten the message. ",
+                    "content": commit_prompt_template.render(types=commit_types),
                 },
                 {"role": "user", "content": diff},
             ],
@@ -84,16 +84,20 @@ def get_ai_command() -> str | None:
         )
     except AuthenticationError:
         print("[red]Could not authenticate with OpenAI, please check your API key.[/red]")
-        return
+        return None
     resp = chat_completion.choices[0].message.parsed
-    return get_commit_command(resp.type, resp.scope, resp.msg, settings.get("commit", {}).get("emoji", False), resp.is_breaking)
-
+    return get_commit_command(
+        resp.type,
+        resp.scope,
+        resp.msg,
+        use_emoji=settings.get("commit", {}).get("emoji", False),
+        is_breaking=resp.is_breaking,
+    )
 
-def handle_commit(args: CommitArgs):
 
-    global commit_type
+def handle_commit(args: CommitArgs) -> None:
     prefix = ["", "!"]
-    choices = ["".join(data) for data in itertools.product(commit_type, prefix)] + ["ci", "test", "version"]
+    choices = ["".join(data) for data in itertools.product(commit_types, prefix)] + ["ci", "test", "version"]
 
     if args.ai:
         command = get_ai_command()
@@ -105,7 +109,7 @@ def handle_commit(args: CommitArgs):
             print("Please provide a commit message, or use --ai to generate by AI")
             return
         commit_type = messages[0]
-        if len(messages) > 2:
+        if len(messages) > 2:  # noqa: PLR2004
             commit_scope = messages[1]
             commit_msg = " ".join(messages[2:])
         else:
@@ -116,8 +120,8 @@ def handle_commit(args: CommitArgs):
             print(f"Valid types: {choices}")
             return
         use_emoji = args.emoji
-        if use_emoji == False:
+        if use_emoji is False:
             use_emoji = settings.get("commit", {}).get("emoji", False)
         is_breaking = args.breaking
-        command = get_commit_command(commit_type, commit_scope, commit_msg, use_emoji, is_breaking)
+        command = get_commit_command(commit_type, commit_scope, commit_msg, use_emoji=use_emoji, is_breaking=is_breaking)
     run_command(command)

tgit-0.10.2/tgit/prompts/commit.txt

@@ -0,0 +1,26 @@
+You are a git bot. You should read the diff and suggest a commit message.
+
+Type:
+
+The type should be one of {{ types | join(', ') }}.
+
+Scope:
+
+The scope should be short, it is better to be a single word, if there are more than one word, you should use '-'
+
+Message:
+
+The message should in all lowercase.
+The message should be short, in just few words.
+The message should cover all the changes in the diff.
+The message should be in present tense.
+If the change has many parts, you can '&&' to separate them, and you should also shorten the message.
+
+Breaking Change:
+
+Only if the changes are not compatible with previous versions (change the API, break the build, etc.), you should suggest a breaking change.
+
+Additional Considerations:
+
+Search the name and instruction online for the copyright content check.
+Make sure to search the name and instruction online for the copyright content check.

{tgit-0.10.0 → tgit-0.10.2}/tgit/utils.py

@@ -26,7 +26,7 @@ type_emojis = {
 }
 
 
-def get_commit_command(commit_type: str, commit_scope: Optional[str], commit_msg: str, use_emoji=False, is_breaking=False):
+def get_commit_command(commit_type: str, commit_scope: str | None, commit_msg: str, *, use_emoji: bool = False, is_breaking: bool = False):
     if commit_type.endswith("!"):
         commit_type = commit_type[:-1]
         is_breaking = True
@@ -42,8 +42,8 @@ def get_commit_command(commit_type: str, commit_scope: Optional[str], commit_msg
     return f'git commit -m "{msg}"'
 
 
-def simple_run_command(command: str):
-    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+def simple_run_command(command: str) -> None:
+    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)  # noqa: S602
     stdout, stderr = process.communicate()
     if stderr != b"" and process.returncode != 0:
         sys.stderr.write(stderr.decode())
@@ -51,7 +51,7 @@ def simple_run_command(command: str):
         sys.stdout.write(stdout.decode())
 
 
-def run_command(command: str):
+def run_command(command: str) -> None:
     if settings.get("show_command", True):
         panel = Panel.fit(
             Syntax(command, "bash", line_numbers=False, theme="github-dark", background_color="default", word_wrap=True),
@@ -62,11 +62,10 @@ def run_command(command: str):
             title_align="left",
             subtitle_align="right",
         )
-        print()
+        print()  # noqa: T201
         console.print(panel)
 
     if not settings.get("skip_confirm", False):
-
         ok = inquirer.prompt([inquirer.Confirm("continue", message="Do you want to continue?", default=True)])
         if not ok or not ok["continue"]:
             return