Python script to synchronise your locally cloned fork to its parent github repository

Question

I recently wrote a python script that syncs your locally clone repository to its parent repository, so I would like you to review it and help me in improving it.

#!/usr/bin/python3
# coding=utf-8

__author__ = "Ratan Kulshreshtha"
__github__ = "RatanShreshtha"

import os
import sys
from subprocess import call, check_output

import requests

"""
   This script runs a bunch of boilerplate code to synchronise
   your locally cloned fork to its parent github repository.
"""

CURRENT_REPO_ORIGIN = ['git', 'config', '--get', 'remote.origin.url']
CURRENT_REPO_UPSTREAM = ['git', 'config', '--get', 'remote.upstream.url']
ADD_REMOTE_CMD = ['git', 'remote', 'add', 'upstream']
CHECK_REMOTES_CMD = ['git', 'remote', '-v']
FETCH_UPSTREAM_CMD = ['git', 'fetch', 'upstream']
CHECKOUT_MASTER_CMD = ['git', 'checkout', 'master']
MERGE_UPSTREAM_CMD = ['git', 'merge', 'upstream/master']
PUSH_TO_UPSTREAM_CMD = ['git', 'push', 'origin', 'master']


def checkGitRepository():
    """
        Returns True if the repository is a git repository.
    """
    return os.path.isdir('.git')


def getRepoOriginUrl():
    """
        Return origin url of the git repository.
    """

    try:
        repo_origin_url = str(check_output(CURRENT_REPO_ORIGIN))
        repo_origin_url = repo_origin_url.replace("b'", "").replace("\\n'", "")

        print("origin url for this repository:- ", repo_origin_url)
        return repo_origin_url
    except Exception as e:
        print("Unable to get origin url for the repository")
        print(e)
        raise


def getRepoUpstreamUrl():
    """
        Return upstream url of the git repository.
    """

    try:
        repo_upstream_url = str(check_output(CURRENT_REPO_UPSTREAM))
        repo_upstream_url = repo_upstream_url.replace("b'", "")
        repo_upstream_url = repo_upstream_url.replace("\\n'", "")

        print("upstream url for this repository:- ", repo_upstream_url)
        return repo_upstream_url
    except Exception as e:
        print("Unable to get upstream url for the repository")
        print(e)
        raise


def fetchUpstream():
    """
        Fetches upstream changes to your local repository.
    """

    try:
        print("Fetching upstream...")
        print(".........")

        call(FETCH_UPSTREAM_CMD)

        print("Upstream fetch done")

    except Exception as e:
        print("Unable to fetch upstream for the repository")
        print(e)
        raise


def checkoutMasterBranch():
    """
        Checkouts master branch of the repository.
    """

    try:
        print("Checking out master")
        print(".........")

        call(CHECKOUT_MASTER_CMD)

        print("Master checkout done")
    except Exception as e:
        print("Unable to checkout master branch")
        print(e)
        raise


def mergeUpstream():
    """
        Merges upstream and local branch.
    """
    try:
        print("Merging master")
        print("..........")

        call(MERGE_UPSTREAM_CMD)

        print("Syncing done.")
    except Exception as e:
        print("Unable to merge.")
        print(e)
        raise


def pushToOrigin():
    """
        Pushes the locally sysnced code to your remote fork.
    """
    try:
        print("Pushing to origin master")
        print("........")

        call(PUSH_TO_UPSTREAM_CMD)

        print("Push done.")
    except Exception as e:
        print("Unable to push to origin")
        print(e)
        raise


def addRepoUpstream():
    """
        Adds upstream url of parent repository to the locally cloned
        fork if upstream not available.
    """

    repo_origin_url = getRepoOriginUrl()

    if repo_origin_url[0] == "h":
        url_segments = repo_origin_url.split("https://github.com/")

    if repo_origin_url[0] == "g":
        url_segments = repo_origin_url.split("[email protected]:")

    user_and_repo = url_segments[1]
    user_and_repo = user_and_repo.replace(".git", "")
    user, repo = user_and_repo.split("/")

    print("Getting upstream url for the repo ...")
    url = "https://api.github.com/repos/{}/{}".format(user, repo)

    try:
        response = requests.get(url)
        repo_upstream_url = response.json()["parent"]["clone_url"]

        print("Upstream URL is:-", repo_upstream_url)

        ADD_REMOTE_CMD.append(repo_upstream_url)
        print(ADD_REMOTE_CMD)

        print("Upstream is added to the fork")
        call(ADD_REMOTE_CMD)
    except Exception as e:
        print("Unable to add upstream url to the repository")
        print(e)
        raise


def sync():
    """
        Main function to sync the local forks with parents repository.
    """
    print("-" * 120)
    print("|" + "Starting Fork Syncing Process".center(118) + "|")
    print("-" * 120)

    # Check if the current repository is a git repository
    assert checkGitRepository()

    # Check if the git repository has a origin
    assert getRepoOriginUrl()

    try:
        # Now try to get the upstream for the repository.
        assert getRepoUpstreamUrl()

        # If upstream is present do following.
        # First fetch the upstream
        fetchUpstream()

        # Then checkout master branch
        checkoutMasterBranch

        # Then merge upstream master and local branch
        mergeUpstream()

        # Now finally push the delta to the origin master
        pushToOrigin()
    except Exception as e:
        print(e)
        print("Trying to add upstream automatically.")

        # Since upstream is not present do following
        # First add the upstream of the parent repository.
        addRepoUpstream()

        # Then fetch the upstream
        fetchUpstream()

        # Then checkout master branch
        checkoutMasterBranch

        # Then merge upstream master and local branch
        mergeUpstream()

        # Now finally push the delta to the origin master
        pushToOrigin()

    print("-" * 120)
    print("|" + "Ending Fork Syncing Process".center(118) + "|")
    print("-" * 120)


if __name__ == '__main__':
    print(os.getcwd())

    if len(sys.argv) > 1:
        repository_to_be_synced = sys.argv[1]

    os.chdir(repository_to_be_synced)
    print(os.getcwd())

    sync()

Answer 1

Overall, the code is organized in a modular fashion and it's clear what is going on. There are some things that need improvement though.

Code Style Improvements

• follow Python naming conventions - you are using camel case style a lot, but, in Python, it is only used for class names
• there are also some rules violated regarding the docstrings style. For instance, if it fits one line, don't add newlines; always start it with an upper case character and end with a dot

Other ideas

• you can replace if repo_origin_url[0] == "h" (same for the g) with a more readable str.startswith() call:

  if repo_origin_url.startswith("h"):
  

  Or, you may even take it a step further and check for http and git substrings - it may be clearer from readability perspective.

Other high-level ideas

• check out some git Python modules - you may replace manually constructing the git commands and subprocess calls with nice Python function calls. For example, there is that mature gitpython package
• notice that most of your functions have the same layout - you have the main "meat" of the functions put into the try/except blocks. See if you can avoid that and just wrap the function calls with a single try/except instead
• I think you are overloading the code with comments more than you should. The downside of putting a lot of comments is it they should always be up-to-date with the code they are attached to, it's easy to forget to update a comment after updating the relevant block of code. This may lead to confusing situations