githubtakeout 0.1.5__tar.gz → 0.1.7__tar.gz

{githubtakeout-0.1.5/src/githubtakeout.egg-info → githubtakeout-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: githubtakeout
-Version: 0.1.5
+Version: 0.1.7
 Summary: Archive public Git Repos and Gists from GitHub
 Author: Corey Goldberg
 Maintainer: Corey Goldberg

{githubtakeout-0.1.5 → githubtakeout-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "githubtakeout"
-version = "0.1.5"
+version = "0.1.7"
 description = "Archive public Git Repos and Gists from GitHub"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -35,8 +35,8 @@ homepage = "https://github.com/cgoldberg/githubtakeout"
 source = "https://github.com/cgoldberg/githubtakeout"
 download = "https://pypi.org/project/githubtakeout"
 
-[tool.setuptools.packages.find]
-where = ["src"]
+[tool.setuptools]
+package-dir = {"" = "src"}
 
 [tool.black]
 line-length = 88

{githubtakeout-0.1.5 → githubtakeout-0.1.7/src/githubtakeout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: githubtakeout
-Version: 0.1.5
+Version: 0.1.7
 Summary: Archive public Git Repos and Gists from GitHub
 Author: Corey Goldberg
 Maintainer: Corey Goldberg

{githubtakeout-0.1.5 → githubtakeout-0.1.7}/src/githubtakeout.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 LICENSE
 README.md
 pyproject.toml
+src/githubtakeout.py
+src/progress.py
 src/githubtakeout.egg-info/PKG-INFO
 src/githubtakeout.egg-info/SOURCES.txt
 src/githubtakeout.egg-info/dependency_links.txt

githubtakeout-0.1.7/src/githubtakeout.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+githubtakeout
+progress

githubtakeout-0.1.7/src/githubtakeout.py

@@ -0,0 +1,254 @@
+# Corey Goldberg, 2025
+# License: MIT
+
+"""Archive Git Repos and Gists from GitHub"""
+
+import argparse
+import getpass
+import logging
+import math
+import os
+import shutil
+import stat
+import sys
+import tarfile
+import urllib
+import zipfile
+from pathlib import Path
+from timeit import default_timer
+
+import git
+import github
+
+from progress import GitProgress
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger(__name__)
+
+
+def convert_size(size_bytes):
+    if size_bytes == 0:
+        return "0 B"
+    size_name = ("B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"
+
+
+def add_creds(url, username, token):
+    if token is None:
+        new_url = url
+    else:
+        username = urllib.parse.quote(username)
+        url_parts = urllib.parse.urlparse(url)
+        netloc = f"{username}:{token}@{url_parts.netloc}"
+        new_url = urllib.parse.urlunparse(url_parts._replace(netloc=netloc))
+    return new_url
+
+
+def archive(local_repo_dir, archive_format="zip", is_gist=False):
+    if archive_format not in ("tar", "zip"):
+        raise ValueError(f"{archive_format} is not a valid archive format")
+    base_name = os.path.basename(local_repo_dir)
+    extension = "tar.gz" if archive_format == "tar" else archive_format
+    archive_name = f"{base_name}.{extension}"
+    if is_gist:
+        archive_name = f"gist-{archive_name}"
+    parent_dir = os.path.dirname(local_repo_dir)
+    archive_path = os.path.join(parent_dir, archive_name)
+    logger.info(f"creating archive: {archive_path}")
+    if archive_format == "tar":
+        with tarfile.open(archive_path, "w:gz") as tar_archive:
+            tar_archive.add(local_repo_dir, arcname=base_name)
+    elif archive_format == "zip":
+        with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as zip_archive:
+            repo_path = Path(local_repo_dir)
+            for entry in repo_path.rglob("*"):
+                path = os.path.join(base_name, entry.relative_to(repo_path))
+                zip_archive.write(entry, arcname=path)
+    return archive_path
+
+
+def clone(repo_url, local_repo_dir, include_history):
+    try:
+        if include_history:
+            # full clone
+            repo = git.Repo.clone_from(
+                url=repo_url, to_path=local_repo_dir, progress=GitProgress()
+            )
+        else:
+            # shallow clone (no commit history or branches)
+            repo = git.Repo.clone_from(
+                url=repo_url, to_path=local_repo_dir, depth=1, progress=GitProgress()
+            )
+    except git.GitCommandError as e:
+        logger.error(e)
+        sys.exit("error: failed cloning repo")
+    finally:
+        try:
+            # release resources
+            repo.close()
+        except UnboundLocalError:
+            # this occurs if we catch a signal while cloning
+            pass
+
+
+def clone_and_archive_repo(
+    repo_url, local_repo_dir, archive_format, include_history, is_gist=False
+):
+    def remove_readonly(func, path, _):
+        # This is necessary so rmtree() doesn't fail if there are any readonly
+        # dirs/files when trying to delete. This seems to happen after cloning on
+        # Windows. When any error occurs during deletion, we change the permissions
+        # and and reattempt removal.
+        #
+        # give read permissions
+        os.chmod(path, stat.S_IREAD)
+        # give write permissions
+        os.chmod(path, stat.S_IWRITE)
+        # try again
+        func(path)
+
+    try:
+        # delete repo if it already exists
+        shutil.rmtree(local_repo_dir, onexc=remove_readonly)
+    except FileNotFoundError:
+        pass
+    repo_name = urllib.parse.urlparse(repo_url).path.lstrip("/")
+    logger.info(f"cloning repo: {repo_name} to {local_repo_dir}")
+    start = default_timer()
+    clone(repo_url, local_repo_dir, include_history)
+    if not include_history:
+        # delete the .git directory if we are not saving history
+        try:
+            git_dir = os.path.join(local_repo_dir, ".git")
+            shutil.rmtree(git_dir, onexc=remove_readonly)
+        except FileNotFoundError:
+            pass
+    archive_path = archive(local_repo_dir, archive_format, is_gist)
+    size = convert_size(os.path.getsize(archive_path))
+    logger.info(f"archive size: {size}")
+    logger.info("deleting repo")
+    try:
+        # delete repo after archive is created
+        shutil.rmtree(local_repo_dir, onexc=remove_readonly)
+    except FileNotFoundError:
+        pass
+    elapsed = default_timer() - start
+    base_name = os.path.basename(local_repo_dir)
+    logger.info(f"successfully backed up '{base_name}' repo in {elapsed:.3f} secs\n")
+
+
+def get_user(username, prompt_token):
+    if prompt_token:
+        token = getpass.getpass("Token:")
+        if not token:
+            sys.exit("error: auth token cannot be empty")
+        auth = github.Auth.Token(token)
+        gh = github.Github(auth=auth)
+    else:
+        token = os.getenv("GITHUB_TOKEN")
+        if token is not None:
+            auth = github.Auth.Token(token)
+            gh = github.Github(auth=auth)
+        else:
+            gh = github.Github()
+    if token is None:
+        try:
+            user = gh.get_user(username)
+        except github.GithubException as e:
+            if e.data["status"] == "404":
+                sys.exit(f"error: user '{username}' not found")
+            else:
+                raise e
+        repos = user.get_repos()
+    else:
+        # you need to be authenticated and then call the API
+        # with no username to get private repos
+        user = gh.get_user()
+        repos = user.get_repos(affiliation="owner")
+        try:
+            # this just makes an API request so we can exit if unauthorized
+            _ = repos.totalCount
+        except github.GithubException as e:
+            if e.data["status"] == "401":
+                sys.exit(f"error: invalid auth token for user '{username}'")
+            else:
+                raise e
+    gists = user.get_gists()
+    return user, repos, gists, token
+
+
+def run(
+    username,
+    base_dir,
+    archive_format,
+    include_gists,
+    include_history,
+    list_only,
+    prompt_token,
+):
+    working_dir = os.path.join(base_dir, "backups")
+    user, repos, gists, token = get_user(username, prompt_token)
+    num_repos = repos.totalCount
+    if not list_only:
+        logger.info(f"creating archives in: {working_dir}\n")
+    logger.info(f"found {num_repos} repos for user '{username}'\n")
+    for repo in repos:
+        local_repo_dir = os.path.join(working_dir, repo.name)
+        url = add_creds(repo.clone_url, username, token)
+        if list_only:
+            logger.info(url)
+        else:
+            clone_and_archive_repo(url, local_repo_dir, archive_format, include_history)
+    if include_gists:
+        num_gists = gists.totalCount
+        logger.info("")
+        logger.info(f"found {num_gists} gists for user '{username}'\n")
+        for gist in gists:
+            local_repo_dir = os.path.join(working_dir, gist.id)
+            url = add_creds(gist.git_pull_url, username, token)
+            if list_only:
+                logger.info(url)
+            else:
+                clone_and_archive_repo(
+                    url, local_repo_dir, archive_format, include_history, is_gist=True
+                )
+
+
+def main():
+    if sys.version_info < (3, 12):
+        sys.exit("sorry, this program requires Python 3.12+")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("username", help="github username")
+    parser.add_argument("--dir", default=os.getcwd(), help="output directory")
+    parser.add_argument("--format", default="zip", help="archive format (tar, zip)")
+    parser.add_argument(
+        "--gists", action="store_true", default=False, help="include gists"
+    )
+    parser.add_argument(
+        "--history",
+        action="store_true",
+        default=False,
+        help="include commit history and branches (.git directory)",
+    )
+    parser.add_argument(
+        "--list", action="store_true", default=False, help="list repos only"
+    )
+    parser.add_argument(
+        "--token", action="store_true", default=False, help="prompt for auth token"
+    )
+    args = parser.parse_args()
+    try:
+        run(
+            username=args.username,
+            base_dir=args.dir,
+            archive_format=args.format,
+            include_gists=args.gists,
+            include_history=args.history,
+            list_only=args.list,
+            prompt_token=args.token,
+        )
+    except KeyboardInterrupt:
+        sys.exit("\nexiting program ...")

githubtakeout-0.1.7/src/progress.py

@@ -0,0 +1,73 @@
+import git
+from rich import console, progress
+
+# adapted from: https://stackoverflow.com/a/71285627/16148
+
+
+class GitProgress(git.RemoteProgress):
+    OP_CODES = [
+        "BEGIN",
+        "CHECKING_OUT",
+        "COMPRESSING",
+        "COUNTING",
+        "END",
+        "FINDING_SOURCES",
+        "RECEIVING",
+        "RESOLVING",
+        "WRITING",
+    ]
+    OP_CODE_MAP = {
+        getattr(git.RemoteProgress, _op_code): _op_code for _op_code in OP_CODES
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.progressbar = progress.Progress(
+            progress.SpinnerColumn(),
+            progress.TextColumn("[progress.description]{task.description}"),
+            progress.BarColumn(),
+            progress.TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            "eta",
+            progress.TimeRemainingColumn(),
+            progress.TextColumn("{task.fields[message]}"),
+            console=console.Console(),
+            transient=False,
+        )
+        self.progressbar.start()
+        self.active_task = None
+
+    def __del__(self):
+        self.progressbar.stop()
+
+    @classmethod
+    def get_curr_op(cls, op_code):
+        """Get OP name from OP code."""
+        # Remove BEGIN-flag and END-flag and get op name
+        op_code_masked = op_code & cls.OP_MASK
+        return cls.OP_CODE_MAP.get(op_code_masked, "?").title()
+
+    def update(self, op_code, cur_count, max_count=None, message=""):
+        # Start new bar on each BEGIN-flag
+        if op_code & self.BEGIN:
+            self.curr_op = self.get_curr_op(op_code)
+            if self.get_curr_op(op_code) == "Receiving":
+                self.active_task = self.progressbar.add_task(
+                    description=self.curr_op,
+                    total=max_count,
+                    message=message,
+                )
+
+        if self.get_curr_op(op_code) == "Receiving":
+            self.progressbar.update(
+                task_id=self.active_task,
+                completed=cur_count,
+                message=message,
+            )
+
+        # End progress monitoring on each END-flag
+        if self.get_curr_op(op_code) == "Receiving":
+            if op_code & self.END:
+                self.progressbar.update(
+                    task_id=self.active_task,
+                    message=f"[bright_black]{message}",
+                )

githubtakeout-0.1.5/src/githubtakeout.egg-info/top_level.txt

@@ -1 +0,0 @@
-