ghot 0.1.0__tar.gz

ghot-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+venv/
+.venv/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+.coverage
+
+# Mkdocs
+.cache
+site/

ghot-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: ghot
+Version: 0.1.0
+Summary: GitHub Organization Tools
+Project-URL: Documentation, https://joapuiib.github.io/github-organization-tools
+Project-URL: Download, https://github.com/joapuiib/github-organization-tools/releases
+Project-URL: Homepage, https://joapuiib.github.io/github-organization-tools
+Project-URL: Source, https://github.com/joapuiib/github-organization-tools
+Project-URL: Tracker, https://github.com/joapuiib/github-organization-tools/issues
+Author-email: Joan Puigcerver <joapuiib@gmail.com>
+License-Expression: MIT
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: colorama
+Requires-Dist: gitpython
+Requires-Dist: keyring
+Requires-Dist: pygithub
+Description-Content-Type: text/markdown
+
+# GitHub Organization Tools
+
+__GitHub Organization Tools (`ghot`)__ is a CLI tool designed to simplify the management of users and repositories
+within a GitHub organization.
+
+__Features__:
+
+- Invite and remove users from your organization.
+- Create, clone, pull or delete repositories.
+- Create issues to multiple repositories.
+
+## Installation
+This tool can be installed via `pip`:
+
+```bash
+pip install ghot
+```
+
+## Quick Start Example
+- Create a new [organization][org] in GitHub.
+
+[org]: https://docs.github.com/articles/creating-a-new-organization-from-scratch
+
+- Define a CSV file with the users and repositories.
+    ```csv
+    id,username,repo
+    id1,user1,user1-repo
+    id2,user2,user2-repo
+    ```
+
+    > - `id` is a custom identifier for the user.
+    > - `username` is the GitHub username.
+    > - `repo` is the repository name in the organization.
+    >
+    > Check the [documentation](https://joapuiib.github.io/github-organization-tools/) for more details!
+
+- Invite users to the organization:
+    ```bash
+    ghot user invite my-org users.csv
+    ```
+
+- Let users accept the invitation and create their repositories — Or do it for them!
+    ```bash
+    ghot repo create my-org users.csv
+    ghot repo invite my-org users.csv
+    ```
+
+- And clone the repositories!
+    ```bash
+    ghot repo clone my-org users.csv
+    ```

ghot-0.1.0/README.md

@@ -0,0 +1,51 @@
+# GitHub Organization Tools
+
+__GitHub Organization Tools (`ghot`)__ is a CLI tool designed to simplify the management of users and repositories
+within a GitHub organization.
+
+__Features__:
+
+- Invite and remove users from your organization.
+- Create, clone, pull or delete repositories.
+- Create issues to multiple repositories.
+
+## Installation
+This tool can be installed via `pip`:
+
+```bash
+pip install ghot
+```
+
+## Quick Start Example
+- Create a new [organization][org] in GitHub.
+
+[org]: https://docs.github.com/articles/creating-a-new-organization-from-scratch
+
+- Define a CSV file with the users and repositories.
+    ```csv
+    id,username,repo
+    id1,user1,user1-repo
+    id2,user2,user2-repo
+    ```
+
+    > - `id` is a custom identifier for the user.
+    > - `username` is the GitHub username.
+    > - `repo` is the repository name in the organization.
+    >
+    > Check the [documentation](https://joapuiib.github.io/github-organization-tools/) for more details!
+
+- Invite users to the organization:
+    ```bash
+    ghot user invite my-org users.csv
+    ```
+
+- Let users accept the invitation and create their repositories — Or do it for them!
+    ```bash
+    ghot repo create my-org users.csv
+    ghot repo invite my-org users.csv
+    ```
+
+- And clone the repositories!
+    ```bash
+    ghot repo clone my-org users.csv
+    ```

ghot-0.1.0/ghot/auth.py

@@ -0,0 +1,52 @@
+import getpass
+import keyring
+from github import Github, Auth
+
+SERVICE_NAME = "github_pat"
+
+class AuthManager:
+    def __init__(self):
+        self.system_user = getpass.getuser()
+        self._load_token()
+
+
+    def _load_token(self):
+        self.token = keyring.get_password(SERVICE_NAME, self.system_user)
+
+
+    def init(self):
+        if not self.token:
+            self.token = getpass.getpass("Enter your GitHub Personal Access Token: ").strip()
+            if input("Save this token for future use? (y/n): ").strip().lower() == 'y':
+                keyring.set_password(SERVICE_NAME, self.system_user, self.token)
+
+
+    def has_token(self):
+        return self.token is not None
+
+
+    def client(self):
+        if not self.token:
+            return None
+
+        auth = Auth.Token(self.token)
+        return Github(auth=auth)
+
+
+    def print_token(self):
+        if not self.token:
+            print("No token found.")
+            return
+
+        print(f"Token for user '{self.system_user}': {self.token}")
+
+
+    def remove_token(self):
+        if not self.has_token():
+            print("No token found.")
+            return
+
+        response = input("Are you sure you want to remove the stored key? (y/N): ")
+        if response.lower() == "y":
+            keyring.delete_password(SERVICE_NAME, self.system_user)
+            print(f"Removed token for user '{self.system_user}'.")

ghot-0.1.0/ghot/config.py

@@ -0,0 +1,74 @@
+import configparser
+import os
+
+def load_config():
+    paths = [os.path.expanduser('~/.ghot')]
+    if os.path.exists('.ghot'):
+        paths.append(os.path.abspath('.ghot'))
+
+    config = configparser.ConfigParser(interpolation=None)
+    config.read(paths)
+    return config
+
+
+def apply_config_defaults(parser, config):
+    def set_str(default, section, key):
+        if config.has_option(section, key):
+            parser.set_defaults(**{default: config.get(section, key)})
+
+    def set_bool(default, section, key):
+        if config.has_option(section, key):
+            parser.set_defaults(**{default: config.getboolean(section, key)})
+
+    set_str('pattern_id', 'csv', 'pattern.id')
+    set_str('pattern_username', 'csv', 'pattern.username')
+    set_str('pattern_repo', 'csv', 'pattern.repo')
+    set_str('pattern_description', 'csv', 'pattern.description')
+    set_bool('lower_id', 'csv', 'lower.id')
+    set_bool('remove_accents', 'csv', 'remove.accents')
+
+
+def write_config(key, value, global_scope=False):
+    config_path = os.path.expanduser("~/.ghot") if global_scope else ".ghot"
+    config = configparser.ConfigParser(interpolation=None)
+    config.read(config_path)
+
+    section, key = key.split(".", 1)
+
+    if not config.has_section(section):
+        config.add_section(section)
+
+    config.set(section, key, value)
+
+    with open(config_path, "w") as configfile:
+        config.write(configfile)
+
+
+def show_config(key=None):
+    config = load_config()
+
+    if key is None:
+        for section in config.sections():
+            print(f"[{section}]")
+            for key, value in config.items(section):
+                print(f"{key} = {value}")
+            print()
+        return
+
+    else:
+        section = ""
+        if "." in key:
+            section, key = key.split(".", 1)
+
+        if not config.has_option(section, key):
+            if section:
+                print(f"Config '{section}.{key}' not found.")
+            else:
+                print(f"Config '{key}' not found.")
+            return
+
+        value = config.get(section, key)
+        if section:
+            print(f"{section}.{key} = {value}")
+        else:
+            print(f"{key} = {value}")

ghot-0.1.0/ghot/csv_loader.py

@@ -0,0 +1,54 @@
+import csv
+
+from .user import User
+from .pattern_formatter import PatternFormatter
+
+
+class CSVUserLoader:
+    def __init__(
+            self,
+            pattern_id="",
+            pattern_username="",
+            pattern_repo="",
+            pattern_description="",
+    ):
+        self.pattern_id = pattern_id
+        self.pattern_username = pattern_username
+        self.pattern_repo = pattern_repo
+        self.pattern_description = pattern_description
+
+        self.schema = {}
+        self.formatter = PatternFormatter()
+
+
+    def __repr__(self):
+        return f"CSVUserLoader(pattern_id={self.pattern_id}, pattern_username={self.pattern_username}, pattern_repo={self.pattern_repo}, pattern_description={self.pattern_description}, lower_id={self.lower_id}, remove_accents={self.remove_accents})"
+
+
+    def load(self, path):
+        try:
+            with open(path, newline='') as f:
+                reader = csv.reader(f, delimiter=',')
+                header = next(reader)
+                self.load_schema(header)
+                return [ self.map(row) for row in reader ]
+        except FileNotFoundError:
+            print(f"Could not find file: {path}")
+            exit(1)
+
+
+    def load_schema(self, header):
+        self.schema = {name: idx for idx, name in enumerate(header)}
+        self.formatter.schema = self.schema
+
+
+    def map(self, row):
+        """
+        Maps a CSV line to a User object.
+        """
+        return User(**{
+            "id": self.formatter.format(self.pattern_id, row),
+            "username": self.formatter.format(self.pattern_username, row),
+            "repo": self.formatter.format(self.pattern_repo, row),
+            "description": self.formatter.format(self.pattern_description, row),
+        })

ghot-0.1.0/ghot/ghot.py

@@ -0,0 +1,223 @@
+import argparse
+import sys
+
+from .auth import AuthManager
+from .config import load_config, apply_config_defaults, write_config, show_config
+from .csv_loader import CSVUserLoader
+from .org_manager import OrgManager
+
+__version__ = "0.1.0"
+
+def build_parser():
+    config = load_config()
+    def add_csv_options(parser):
+        parser.add_argument('csv', help='CSV file')
+        parser.add_argument('--pattern-id', default='{f0}', help='Pattern for user ID')
+        parser.add_argument('--pattern-username', default='{f1}', help='Pattern for username')
+        parser.add_argument('--pattern-repo', default='{f2}', help='Pattern for repository name')
+        parser.add_argument('--pattern-description', default='', help='Pattern for repository description')
+        apply_config_defaults(parser, config)
+
+    def add_dry_option(parser):
+        parser.add_argument('--dry', action='store_true', help='Dry run mode')
+
+    parser = argparse.ArgumentParser(description='Git tools.')
+    commands = parser.add_subparsers(title="commands", dest="commands")
+
+    # ghot auth
+    auth_p = commands.add_parser('auth')
+    ## ghot auth check|print|remove
+    auth_p.add_argument('auth_commands', choices=['check', 'remove', 'print'], help='Authentication command')
+
+    # ghot config
+    config_p = commands.add_parser('config')
+    config_commands = config_p.add_subparsers(title="config_commands", dest="config_commands", required=True)
+    ## ghot config [set] [--global] <key> <value>
+    config_set_p = config_commands.add_parser('set')
+    config_set_p.add_argument('--global', dest="_global", action='store_true', help='Set the config globally')
+    config_set_p.add_argument('key', help='Config key to set')
+    config_set_p.add_argument('value', help='Config value to set')
+    ## ghot config show <key>
+    config_show_p = config_commands.add_parser('show')
+    config_show_p.add_argument('key', help='Config key to show', nargs='?', default=None)
+
+    # ghot user
+    user_p = commands.add_parser('user')
+    user_commands = user_p.add_subparsers(title="user_commands", dest="user_commands", required=True)
+    ## ghot user invite <org> <csv>
+    user_invite_p = user_commands.add_parser('invite')
+    user_invite_p.add_argument("org", help='Organization name')
+    add_csv_options(user_invite_p)
+    add_dry_option(user_invite_p)
+    ## ghot user remove <org> <csv> [-f|--force]
+    user_remove_p = user_commands.add_parser('remove')
+    user_remove_p.add_argument("org", help='Organization name')
+    add_csv_options(user_remove_p)
+    add_dry_option(user_remove_p)
+    user_remove_p.add_argument("-f", "--force", action="store_true", default=False, help='Force removal')
+
+    # ghot repo
+    repo_p = commands.add_parser('repo')
+    repo_commands = repo_p.add_subparsers(title="repo_commands", dest="repo_commands", required=True)
+    ## ghot repo create [--public] [--private] <org> <csv>
+    repo_create_p = repo_commands.add_parser('create')
+    repo_create_p.add_argument("org", help='Organization name')
+    add_csv_options(repo_create_p)
+    add_dry_option(repo_create_p)
+    repo_create_p.add_argument('--public', action='store_true', help='Create public repositories')
+    repo_create_p.add_argument('--private', action='store_true', help='Create private repositories')
+    ## ghot repo clone [-d|--destination <path>] <csv>
+    repo_clone_p = repo_commands.add_parser('clone')
+    repo_clone_p.add_argument("org", help='Organization name')
+    add_csv_options(repo_clone_p)
+    add_dry_option(repo_clone_p)
+    repo_clone_p.add_argument('-d', '--destination', help='Destination directory where the repositoiry will be cloned')
+    repo_clone_p.add_argument('--ssh', action='store_true', help='Use SSH for cloning')
+    ## ghot repo pull [-d|--destination <path>] <csv>
+    repo_pull_p = repo_commands.add_parser('pull')
+    add_csv_options(repo_pull_p)
+    add_dry_option(repo_pull_p)
+    repo_pull_p.add_argument('-d', '--destination', help='Destination directory where the repositoiry will be pulled')
+    ## ghot repo delete [-f|--force] <org> <csv>
+    repo_delete_p = repo_commands.add_parser('delete')
+    repo_delete_p.add_argument('org', help='Organization name')
+    add_csv_options(repo_delete_p)
+    add_dry_option(repo_delete_p)
+    repo_delete_p.add_argument('-f', '--force', action='store_true', default=False, help='Force deletion')
+    ## ghot repo invite <org> <csv>
+    repo_invite_p = repo_commands.add_parser('invite')
+    repo_invite_p.add_argument('org', help='Organization name')
+    add_csv_options(repo_invite_p)
+    add_dry_option(repo_invite_p)
+
+    # ghot issue
+    issue_p = commands.add_parser('issue')
+    issue_commands = issue_p.add_subparsers(title="issue_commands", dest="issue_commands", required=True)
+    ## ghot issue create <org> <csv> <title> <body>
+    issue_create_p = issue_commands.add_parser('create')
+    issue_create_p.add_argument('org', help='Organization name')
+    add_csv_options(issue_create_p)
+    issue_create_p.add_argument('title', help='Issue title')
+    issue_create_p.add_argument('body', help='Issue body')
+    add_dry_option(issue_create_p)
+
+    return parser
+
+
+def preprocess_args(argv):
+    if len(argv) > 2:
+        if argv[1] == "config" and argv[2] not in ["set", "show"]:
+            argv.insert(2, "set")
+
+    return argv
+
+
+def handle_config(args):
+    # Default config action
+    if args.config_commands is None:
+        args.config_commands = "set"
+
+    match args.config_commands:
+        case "set":
+            write_config(args.key, args.value, global_scope=args._global)
+        case "show":
+            show_config(args.key)
+
+
+def handle_auth(args):
+    auth = AuthManager()
+    match args.auth_commands:
+        case "check":
+            auth.init()
+            print(f"Authenticated as {auth.client().get_user().login}")
+        case "print":
+            auth.print_token()
+        case "remove":
+            auth.remove_token()
+
+
+def handle_user(args):
+    org_manager = init_org_manager(args)
+    users = load_users(args)
+
+    match args.user_commands:
+        case "invite":
+            org_manager.user_invite(args.org, users, dry=args.dry)
+        case "remove":
+            org_manager.user_remove(args.org, users, dry=args.dry, force=args.force)
+
+
+def handle_repo(args):
+    org_manager = init_org_manager(args)
+    users = load_users(args)
+
+    match args.repo_commands:
+        case "create":
+            private = True
+            if args.public and not args.private:
+                private = False
+
+            org_manager.repo_create(args.org, users, private=private, dry=args.dry)
+
+        case "clone":
+            org_manager.repo_clone(args.org, users, destination=args.destination, dry=args.dry, ssh=args.ssh)
+        case "pull":
+            org_manager.repo_pull(users, destination=args.destination, dry=args.dry)
+        case "delete":
+            org_manager.repo_delete(args.org, users, dry=args.dry, force=args.force)
+        case "invite":
+            org_manager.repo_invite(args.org, users, dry=args.dry)
+
+
+def handle_issue(args):
+    org_manager = init_org_manager(args)
+    users = load_users(args)
+
+    match args.issue_commands:
+        case "create":
+            org_manager.issue_create(args.org, users, args.title, args.body, dry=args.dry)
+
+
+def init_org_manager(args):
+    auth = AuthManager()
+    auth.init()
+    org_manager = OrgManager(auth.client())
+    return org_manager
+
+
+def load_users(args):
+    csv_loader = CSVUserLoader(
+        pattern_id=args.pattern_id,
+        pattern_username=args.pattern_username,
+        pattern_repo=args.pattern_repo,
+        pattern_description=args.pattern_description,
+    )
+    users = csv_loader.load(args.csv)
+    return users
+
+
+def main():
+    sys.argv = preprocess_args(sys.argv)
+    parser = build_parser()
+    args = parser.parse_args()
+
+    args = parser.parse_args()
+
+    try:
+        match args.commands:
+            case "auth":
+                handle_auth(args)
+            case "config":
+                handle_config(args)
+            case "user":
+                handle_user(args)
+            case "repo":
+                handle_repo(args)
+            case "issue":
+                handle_issue(args)
+
+    except KeyboardInterrupt:
+        print("\nCancelled by user.")
+    except ValueError as e:
+        # print on stderr
+        print(e, file=sys.stderr)