tgit 0.1.0__tar.gz → 0.2.2__tar.gz

tgit-0.2.2/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: tgit
+Version: 0.2.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>
+Maintainer-email: Jannchie <jannchie@gmail.com>
+Keywords: git,tool,changelog,version,commit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+Requires-Dist: PyYAML
+Requires-Dist: inquirer

tgit-0.2.2/pyproject.toml

@@ -0,0 +1,29 @@
+
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tgit"
+version = "0.2.2"
+description = "Tool for Git Interaction Temptation (tgit): An elegant CLI tool that simplifies and streamlines your Git workflow, making version control a breeze."
+requires-python = ">=3.6"
+keywords = ["git", "tool", "changelog", "version", "commit"]
+dependencies = ["rich", "PyYAML", "inquirer"]
+license = { file = "LICENSE" }
+authors = [{ name = "Jannchie", email = "jannchie@gmail.com" }]
+maintainers = [{ name = "Jannchie", email = "jannchie@gmail.com" }]
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Version Control",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+
+[project.scripts]
+tgit = "tgit.cli:main"

tgit-0.2.2/tgit/changelog.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from tgit.utils import console
+
+
+def define_changelog_parser(subparsers):
+    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")
+    parser_changelog.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
+    parser_changelog.set_defaults(func=handle_changelog)
+
+
+@dataclass
+class ChangelogArgs:
+    from_raw: str
+    to_raw: str
+
+
+def handle_changelog(args: ChangelogArgs):
+    from_raw = args.from_raw
+    to_raw = args.to_raw
+    console.log(f"{from_raw} -> {to_raw}")
+    console.log(args)
+    console.log("WIP")

tgit-0.2.2/tgit/cli.py

@@ -0,0 +1,43 @@
+import argparse
+import importlib.metadata
+
+import rich
+import rich.traceback
+
+from tgit.changelog import define_changelog_parser
+from tgit.commit import define_commit_parser
+from tgit.utils import console
+from tgit.version import define_version_parser
+
+rich.traceback.install()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="TGIT cli",
+        prog="tgit",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("--version", action="store_true", help="show version")
+    subparsers = parser.add_subparsers(title="Subcommands")
+
+    define_commit_parser(subparsers)
+    define_version_parser(subparsers)
+    define_changelog_parser(subparsers)
+
+    args = parser.parse_args()
+    handle(parser, args)
+
+
+def handle(parser, args):
+    if hasattr(args, "func"):
+        args.func(args)
+    elif args.version:
+        version = importlib.metadata.version("tgit")
+        console.print(f"TGIT - ver.{version}", highlight=False)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

tgit-0.2.2/tgit/commit.py

@@ -0,0 +1,52 @@
+import itertools
+from dataclasses import dataclass
+from typing import Optional
+
+from tgit.settings import settings
+from tgit.utils import get_commit_command, run_command, type_emojis
+
+
+def define_commit_parser(subparsers):
+    commit_type = ["feat", "fix", "chore", "docs", "style", "refactor", "perf"]
+    prefix = ["!", ""]
+    commit_settings = settings.get("commit", {})
+    types_settings = commit_settings.get("types", [])
+    for data in types_settings:
+        type_emojis[data.get("type")] = data.get("emoji")
+        commit_type.append(data.get("type"))
+
+    choices = ["".join(data) for data in itertools.product(commit_type, prefix)] + ["ci", "test", "version"]
+    parser_commit = subparsers.add_parser("commit", help="commit changes following the conventional commit format")
+    parser_commit.add_argument(
+        "type",
+        help="commit type",
+        choices=choices,
+    )
+    parser_commit.add_argument("scope", help="commit scope", type=str, nargs="?")
+    parser_commit.add_argument("message", help="commit message", type=str)
+    parser_commit.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
+    parser_commit.add_argument("-e", "--emoji", action="store_true", help="use emojis")
+    parser_commit.add_argument("-b", "--breaking", action="store_true", help="breaking change")
+    parser_commit.set_defaults(func=handle_commit)
+
+
+@dataclass
+class CommitArgs:
+    type: str
+    scope: Optional[str]
+    message: str
+    emoji: bool
+    breaking: bool
+
+
+def handle_commit(args: CommitArgs):
+
+    commit_type = args.type
+    commit_scope = args.scope
+    commit_msg = args.message
+    use_emoji = args.emoji
+    if use_emoji == 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)
+    run_command(command)

tgit-0.2.2/tgit/settings.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+import yaml
+
+settings = {}
+
+
+def load_global_settings():
+    global_settings_path = [Path.home() / ".tgit.yaml", Path.home() / ".tgit.yml"]
+    return next(
+        (yaml.safe_load(path.read_text()) for path in global_settings_path if path.exists()),
+        None,
+    )
+
+
+def load_workspace_settings():
+    workspace_settings_path = [Path.cwd() / ".tgit.yaml", Path.cwd() / ".tgit.yml"]
+    return next(
+        (yaml.safe_load(path.read_text()) for path in workspace_settings_path if path.exists()),
+        None,
+    )
+
+
+def load_settings():
+    global_settings = load_global_settings()
+    workspace_settings = load_workspace_settings()
+    settings.update(global_settings or {})
+    settings.update(workspace_settings or {})
+    return settings
+
+
+load_settings()

tgit-0.2.2/tgit/utils.py

@@ -0,0 +1,82 @@
+import subprocess
+import sys
+from typing import Optional
+
+import inquirer
+import rich
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+from tgit.settings import settings
+
+console = rich.get_console()
+
+
+type_emojis = {
+    "feat": ":sparkles:",
+    "fix": ":adhesive_bandage:",
+    "chore": ":wrench:",
+    "docs": ":page_with_curl:",
+    "style": ":lipstick:",
+    "refactor": ":hammer:",
+    "perf": ":zap:",
+    "test": ":rotating_light:",
+    "version": ":bookmark:",
+    "ci": ":construction_worker:",
+}
+
+
+def get_commit_command(commit_type: str, commit_scope: Optional[str], commit_msg: str, use_emoji=False, is_breaking=False):
+    if commit_type.endswith("!"):
+        commit_type = commit_type[:-1]
+        is_breaking = True
+        breaking_str = "!"
+    else:
+        breaking_str = "!" if is_breaking else ""
+    if commit_scope is None:
+        msg = f"{commit_type}{breaking_str}: {commit_msg}"
+    else:
+        msg = f"{commit_type}{breaking_str}({commit_scope}): {commit_msg}"
+    if use_emoji:
+        msg = f"{type_emojis.get(commit_type, ':wrench:' )} {msg}"
+    return f'git commit -m "{msg}"'
+
+
+def run_command(command: str):
+    if settings.get("show_command", True):
+        panel = Panel.fit(
+            Syntax(command, "bash", line_numbers=False, theme="github-dark", background_color="default", word_wrap=True),
+            title="The following command will be executed:",
+            border_style="cyan",
+            highlight=True,
+            padding=(1, 4),
+            title_align="left",
+            subtitle_align="right",
+        )
+        print()
+        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
+        console.print()
+
+    with console.status("[bold green]Executing...") as status:
+        # use subprocess to run the command
+        commands = command.split("\n")
+        for command in commands:
+            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            status.update(f"[bold green]Executing: {command}[/bold green]")
+
+            # get the output and error
+            stdout, stderr = process.communicate()
+
+            if process.returncode != 0:
+                status.update("[bold red]Error[/bold red]")
+            else:
+                status.update("[bold green]Execute successful[/bold green]")
+            if stderr != b"" and process.returncode != 0:
+                sys.stderr.write(stderr.decode())
+            if stdout != b"":
+                sys.stdout.write(stdout.decode())

tgit-0.2.2/tgit/version.py

@@ -0,0 +1,385 @@
+import difflib
+import os
+import re
+import subprocess
+import tomllib
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Optional
+
+import inquirer
+from rich.panel import Panel
+
+from tgit.settings import settings
+from tgit.utils import console, get_commit_command, run_command
+
+semver_regex = re.compile(
+    r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
+)
+
+
+@dataclass
+class Version:
+    major: int
+    minor: int
+    patch: int
+    release: Optional[str] = None
+    build: Optional[str] = None
+
+    def __str__(self):
+        if self.release:
+            if self.build:
+                return f"{self.major}.{self.minor}.{self.patch}-{self.release}+{self.build}"
+            return f"{self.major}.{self.minor}.{self.patch}-{self.release}"
+        if self.build:
+            return f"{self.major}.{self.minor}.{self.patch}+{self.build}"
+
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    @classmethod
+    def from_str(cls, version: str):
+        res = semver_regex.match(version)
+        if not res:
+            raise ValueError("Invalid version format")
+        groups = res.groups()
+        major, minor, patch = map(int, groups[:3])
+        release = groups[3]
+        build = groups[4]
+        return cls(major, minor, patch, release, build)
+
+
+@dataclass
+class VersionArgs:
+    version: str
+    verbose: int
+    no_commit: bool
+    no_tag: bool
+    no_push: bool
+    patch: bool
+    minor: bool
+    major: bool
+    prepatch: str
+    preminor: str
+    premajor: str
+
+
+def get_prev_version():
+    # first, check if there is a file with the version, such as a package.json, pyproject.toml, etc.
+
+    # for nodejs
+    if os.path.exists("package.json"):
+        import json
+
+        with open("package.json") as f:
+            json_data = json.load(f)
+            if version := json_data.get("version"):
+                return Version.from_str(version)
+    elif os.path.exists("pyproject.toml"):
+
+        with open("pyproject.toml", "rb") as f:
+            toml_data = tomllib.load(f)
+            if version := toml_data.get("project", {}).get("version"):
+                return Version.from_str(version)
+            if version := toml_data.get("tool", {}).get("poetry", {}).get("version"):
+                return Version.from_str(version)
+            if version := toml_data.get("tool", {}).get("flit", {}).get("metadata", {}).get("version"):
+                return Version.from_str(version)
+            if version := toml_data.get("tool", {}).get("setuptools", {}).get("setup_requires", {}).get("version"):
+                return Version.from_str(version)
+
+    elif os.path.exists("setup.py"):
+        with open("setup.py") as f:
+            setup_data = f.read()
+            if res := re.search(r"version=['\"]([^'\"]+)['\"]", setup_data):
+                return Version.from_str(res[1])
+
+    elif os.path.exists(
+        "Cargo.toml",
+    ):
+        with open("Cargo.toml", "rb") as f:
+            cargo_data = tomllib.load(f)
+            if version := cargo_data.get("package", {}).get("version"):
+                return Version.from_str(version)
+
+    elif os.path.exists("VERSION"):
+        with open("VERSION") as f:
+            version = f.read().strip()
+            return Version.from_str(version)
+    elif os.path.exists("VERSION.txt"):
+        with open("VERSION.txt") as f:
+            version = f.read().strip()
+            return Version.from_str(version)
+
+    # if not, check if there is a git tag with the version
+    status = subprocess.run(["git", "tag"], capture_output=True)
+    if status.returncode == 0:
+        tags = status.stdout.decode().split("\n")
+        for tag in tags:
+            if tag.startswith("v"):
+                return Version.from_str(tag[1:])
+
+    # if not, return 0.0.0
+    return Version(major=0, minor=0, patch=0)
+
+
+def handle_version(args: VersionArgs):
+    verbose = args.verbose
+
+    # check if there is uncommitted changes
+    # status = subprocess.run(["git", "status", "--porcelain"], capture_output=True)
+    # if status.returncode != 0:
+    #     console.print("Error getting git status")
+    #     return
+    # if status.stdout:
+    #     console.print("There are uncommitted changes, please commit or stash them first")
+    #     return
+
+    if verbose > 0:
+        console.print("Bumping version...")
+        console.print("Getting current version...")
+    with console.status("[bold green]Getting current version..."):
+        prev_version = get_prev_version()
+
+    console.print(f"Previous version: [cyan bold]{prev_version}")
+    # get next version
+    next_version = deepcopy(prev_version)
+    if not any([args.version, args.patch, args.minor, args.major, args.prepatch, args.preminor, args.premajor]):
+        ans = inquirer.prompt(
+            [
+                inquirer.List(
+                    "target",
+                    message="Select the version to bump to",
+                    choices=[
+                        VersionChoice(prev_version, bump) for bump in ["patch", "minor", "major", "prepatch", "preminor", "premajor", "previous", "custom"]
+                    ],
+                    carousel=True,
+                ),
+            ]
+        )
+        if not ans:
+            return
+
+        target = ans["target"]
+        assert isinstance(target, VersionChoice)
+        if verbose > 0:
+            console.print(f"Selected target: [cyan bold]{target}")
+
+        # bump the version
+        if target.bump in ["patch", "prepatch"]:
+            next_version.patch += 1
+        elif target.bump in ["minor", "preminor"]:
+            next_version.minor += 1
+            next_version.patch = 0
+        elif target.bump in ["major", "premajor"]:
+            next_version.major += 1
+            next_version.minor = 0
+            next_version.patch = 0
+
+        if target.bump in ["prepatch", "preminor", "premajor"]:
+            ans = inquirer.prompt(
+                [
+                    inquirer.Text(
+                        "identifier",
+                        message="Enter the pre-release identifier",
+                        default="alpha",
+                        validate=lambda _, x: re.match(r"[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*", x).group() == x,
+                    )
+                ]
+            )
+            release = ans["identifier"]
+            next_version.release = release
+        if target.bump == "custom":
+
+            def validate_semver(_, x):
+                res = semver_regex.match(x)
+                return res and res.group() == x
+
+            ans = inquirer.prompt(
+                [
+                    inquirer.Text(
+                        "version",
+                        message="Enter the version",
+                        validate=validate_semver,
+                    )
+                ]
+            )
+            version = ans["version"]
+            next_version = Version.from_str(version)
+        next_version_str = str(next_version)
+
+        # edit files
+
+        if verbose > 0:
+            current_path = os.getcwd()
+            console.print(f"Current path: [cyan bold]{current_path}")
+
+        # check package.json
+        if os.path.exists("package.json"):
+            if verbose > 0:
+                console.print("Updating package.json")
+            with open("package.json", "r") as f:
+                package_json = f.read()
+            package_json = re.sub(r'"version":\s*".*?"', f'"version": "{next_version_str}"', package_json)
+
+            with open("package.json", "w") as f:
+                f.write(package_json)
+
+        if os.path.exists("pyproject.toml"):
+            if verbose > 0:
+                console.print("Updating pyproject.toml")
+            with open("pyproject.toml", "r") as f:
+                pyproject_toml = f.read()
+            new_pyproject_toml = re.sub(r'version\s*=\s*".*?"', f'version = "{next_version_str}"', pyproject_toml)
+            # print diff between the two files
+            old_lines = pyproject_toml.splitlines()
+            new_lines = new_pyproject_toml.splitlines()
+            diff = list(difflib.Differ().compare(old_lines, new_lines))
+            print_lines = {}
+            for i, line in enumerate(diff):
+                if line.startswith("+") or line.startswith("-"):
+                    # console.print(f"[green]{line}")
+                    for j in range(i - 3, i + 3):
+                        if j >= 0 and j < len(diff):
+                            print_lines[j] = diff[j][0]
+
+            diffs = []
+            for i, line in enumerate(diff):
+                line = line.replace("[", "\\[")
+                line = line.strip()
+                if i in print_lines:
+                    if print_lines[i] == "+":
+                        diffs.append(f"[green]{line}[/green]")
+                    elif print_lines[i] == "-":
+                        diffs.append(f"[red]{line}[/red]")
+                    elif print_lines[i] == "?":
+                        # replace the ? with a space
+                        line = line.replace("?", " ")
+                        diffs.append(f"[yellow]{line}[/yellow]")
+                    else:
+                        diffs.append(line)
+            if diffs:
+                console.print(
+                    Panel.fit(
+                        "\n".join(diffs),
+                        border_style="cyan",
+                        title="Diff for pyproject.toml",
+                        title_align="left",
+                        padding=(1, 4),
+                    )
+                )
+
+                ok = inquirer.prompt([inquirer.Confirm("continue", message="Do you want to continue?", default=True)])
+                if not ok or not ok["continue"]:
+                    return
+
+                with open("pyproject.toml", "w") as f:
+                    f.write(new_pyproject_toml)
+
+        git_tag = f"v{next_version_str}"
+
+        commands = []
+        if args.no_commit:
+            if verbose > 0:
+                console.print("Skipping commit")
+        else:
+            commands.append("git add .")
+            use_emoji = settings.get("commit", {}).get("emoji", False)
+            commands.append(get_commit_command("version", None, f"{git_tag}", use_emoji=use_emoji))
+
+        if args.no_tag:
+            if verbose > 0:
+                console.print("Skipping tag")
+        else:
+            commands.append(f"git tag {git_tag}")
+
+        if args.no_push:
+            if verbose > 0:
+                console.print("Skipping push")
+        else:
+            commands.append("git push")
+            commands.append("git push --tag")
+        commands_str = "\n".join(commands)
+        run_command(commands_str)
+        return
+
+
+class VersionChoice:
+    def __init__(self, previous_version: Version, bump: str):
+        self.previous_version = previous_version
+        self.bump = bump
+        if bump == "major":
+            self.next_version = Version(
+                major=previous_version.major + 1,
+                minor=0,
+                patch=0,
+            )
+        elif bump == "minor":
+            self.next_version = Version(
+                major=previous_version.major,
+                minor=previous_version.minor + 1,
+                patch=0,
+            )
+        elif bump == "patch":
+            self.next_version = Version(
+                major=previous_version.major,
+                minor=previous_version.minor,
+                patch=previous_version.patch + 1,
+            )
+        elif bump == "premajor":
+            self.next_version = Version(
+                major=previous_version.major + 1,
+                minor=0,
+                patch=0,
+                release="RELEASE",
+            )
+        elif bump == "preminor":
+            self.next_version = Version(
+                major=previous_version.major,
+                minor=previous_version.minor + 1,
+                patch=0,
+                release="RELEASE",
+            )
+        elif bump == "prepatch":
+            self.next_version = Version(
+                major=previous_version.major,
+                minor=previous_version.minor,
+                patch=previous_version.patch + 1,
+                release="RELEASE",
+            )
+        elif bump == "previous":
+            self.next_version = previous_version
+
+    def __str__(self):
+        if "next_version" in self.__dict__:
+            return f"{self.bump} -> {self.next_version}"
+        else:
+            return self.bump
+
+
+def define_version_parser(subparsers):
+    parser_version = subparsers.add_parser("version", help="bump version of the project")
+    parser_version.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
+    parser_version.add_argument("--no-commit", action="store_true", help="do not commit the changes")
+    parser_version.add_argument("--no-tag", action="store_true", help="do not create a tag")
+    parser_version.add_argument("--no-push", action="store_true", help="do not push the changes")
+
+    # TODO: add option to bump all packages in the monorepo
+    # parser_version.add_argument("-r", "--recursive", action="store_true", help="bump all packages in the monorepo")
+
+    # create a mutually exclusive group
+    version_group = parser_version.add_mutually_exclusive_group()
+
+    # add arguments to the group
+    version_group.add_argument("-p", "--patch", help="patch version", action="store_true")
+    version_group.add_argument("-m", "--minor", help="minor version", action="store_true")
+    version_group.add_argument("-M", "--major", help="major version", action="store_true")
+    version_group.add_argument("-pp", "--prepatch", help="prepatch version", type=str)
+    version_group.add_argument("-pm", "--preminor", help="preminor version", type=str)
+    version_group.add_argument("-pM", "--premajor", help="premajor version", type=str)
+    version_group.add_argument("version", help="version to bump to", type=str, nargs="?")
+    parser_version.set_defaults(func=handle_version)
+    parser_version.set_defaults(func=handle_version)
+    parser_version.set_defaults(func=handle_version)
+    parser_version.set_defaults(func=handle_version)
+    parser_version.set_defaults(func=handle_version)
+    parser_version.set_defaults(func=handle_version)

tgit-0.2.2/tgit.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: tgit
+Version: 0.2.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>
+Maintainer-email: Jannchie <jannchie@gmail.com>
+Keywords: git,tool,changelog,version,commit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: rich
+Requires-Dist: PyYAML
+Requires-Dist: inquirer

tgit-0.2.2/tgit.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+tgit/__init__.py
+tgit/changelog.py
+tgit/cli.py
+tgit/commit.py
+tgit/settings.py
+tgit/utils.py
+tgit/version.py
+tgit.egg-info/PKG-INFO
+tgit.egg-info/SOURCES.txt
+tgit.egg-info/dependency_links.txt
+tgit.egg-info/entry_points.txt
+tgit.egg-info/requires.txt
+tgit.egg-info/top_level.txt

tgit-0.2.2/tgit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tgit = tgit.cli:main

tgit-0.2.2/tgit.egg-info/requires.txt

@@ -0,0 +1,3 @@
+rich
+PyYAML
+inquirer

tgit-0.2.2/tgit.egg-info/top_level.txt

@@ -0,0 +1 @@
+tgit

tgit-0.1.0/PKG-INFO

@@ -1,3 +0,0 @@
-Metadata-Version: 2.1
-Name: tgit
-Version: 0.1.0

tgit-0.1.0/setup.py

@@ -1,8 +0,0 @@
-from setuptools import find_packages, setup
-
-setup(
-    name="tgit",
-    version="0.1.0",
-    packages=find_packages(),
-    entry_points={"console_scripts": ["tgit=cli:main"]},
-)

tgit-0.1.0/tgit.egg-info/PKG-INFO

@@ -1,3 +0,0 @@
-Metadata-Version: 2.1
-Name: tgit
-Version: 0.1.0

tgit-0.1.0/tgit.egg-info/SOURCES.txt

@@ -1,6 +0,0 @@
-setup.py
-tgit.egg-info/PKG-INFO
-tgit.egg-info/SOURCES.txt
-tgit.egg-info/dependency_links.txt
-tgit.egg-info/entry_points.txt
-tgit.egg-info/top_level.txt

tgit-0.1.0/tgit.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-tgit = cli:main

tgit-0.1.0/tgit.egg-info/top_level.txt

@@ -1 +0,0 @@
-