[ci][cling] ruff lint and format

Author: devajithvs

.github/workflows/utilities/sync_cling.py

@@ -4,87 +4,97 @@
 import sys
 
 # Parameters
-CLING_TAG_ROOT_HASH_PREFIX='__internal-root-'
+CLING_TAG_ROOT_HASH_PREFIX = "__internal-root-"
 # Arbitrarily choose a commit hash which is "old enough"
 # In this case, we choose the first commit after the latest
 # cling release at the time of writing, 1.2, i.e. 5ea7949 (in cling)
 # 08f123f8e7 (in ROOT)
 # See Cling https://github.com/root-project/cling/commit/5ea7949
 # ROOT https://github.com/root-project/root/commit/08f123f8e7
-DEFAULT_STARTING_ROOT_HASH = '08f123f8e7'
-CLING_REPO_DIR_NAME = 'cling'
-ROOT_REPO_DIR_NAME = 'root'
-INTERP_DIR_NAME = 'interpreter/cling'
-DEST_INTERP_DIR_NAME = ''
+DEFAULT_STARTING_ROOT_HASH = "08f123f8e7"
+CLING_REPO_DIR_NAME = "cling"
+ROOT_REPO_DIR_NAME = "root"
+INTERP_DIR_NAME = "interpreter/cling"
+DEST_INTERP_DIR_NAME = ""
+
 
 def printError(msg):
-    print(f'*** Error: {msg}')
+    print(f"*** Error: {msg}")
+
 
 def printWarning(msg):
-    print(f'*** Warning: {msg}')
+    print(f"*** Warning: {msg}")
+
 
 def printInfo(msg):
-    print(f'Info: {msg}')
+    print(f"Info: {msg}")
+
 
-def execCommand(cmd, thisCwd = './', theInput = None, desc=""):
-    '''
+def execCommand(cmd, thisCwd="./", theInput=None, desc=""):
+    """
     Execute a command and return the output. For logging reasons, the command
     is also printed.
     If "desc" is specificed, the command is not printed but "desc".
-    '''
-    if '' == desc:
-        printInfo(f'In directory {thisCwd} *** {cmd} {"with std input" if theInput else ""}')
+    """
+    if "" == desc:
+        printInfo(f"In directory {thisCwd} *** {cmd} {'with std input' if theInput else ''}")
     else:
         print(desc)
-    compProc = subprocess.run(cmd, shell=True, capture_output=True, text=True,
-                              cwd=thisCwd, input=theInput, encoding='latin1')
+    compProc = subprocess.run(
+        cmd, shell=True, capture_output=True, text=True, cwd=thisCwd, input=theInput, encoding="latin1"
+    )
     if 0 != compProc.returncode:
         print(f"Error:\n {compProc.stderr.strip()}")
         raise ValueError(f'Command "{cmd}" failed ({compProc.returncode})')
     out = compProc.stdout.strip()
     return out
 
+
 def getAllClingTags():
-    execCommand(f'git fetch --tags', CLING_REPO_DIR_NAME)
+    execCommand("git fetch --tags", CLING_REPO_DIR_NAME)
+
 
 def getRootSyncTag():
     # We try to get the tags, to get the latest ROOT commit that was synchronized
     getAllClingTags()
-    tagsStr = execCommand(f'git tag', CLING_REPO_DIR_NAME)
-    tags = tagsStr.split('\n')
-    if tags == ['']:
-        printInfo(f'No tags found locally. Looking in the source repository.')
-        tagsStr = execCommand(f'git ls-remote --tags origin', CLING_REPO_DIR_NAME)
-        tags = tagsStr.split('\n')
+    tagsStr = execCommand("git tag", CLING_REPO_DIR_NAME)
+    tags = tagsStr.split("\n")
+    if tags == [""]:
+        printInfo("No tags found locally. Looking in the source repository.")
+        tagsStr = execCommand("git ls-remote --tags origin", CLING_REPO_DIR_NAME)
+        tags = tagsStr.split("\n")
         print(tags)
-        tags = list(map(lambda t: t.split('/')[-1] if '/' in t else t, tags))
+        tags = list(map(lambda t: t.split("/")[-1] if "/" in t else t, tags))
         print(tags)
 
-    printInfo(f'Tags found: {str(tags)}')
+    printInfo(f"Tags found: {str(tags)}")
 
     rootTags = list(filter(lambda tag: tag.startswith(CLING_TAG_ROOT_HASH_PREFIX), tags))
     if not rootTags:
-        raise ValueError(f'No sync tags starting with {CLING_TAG_ROOT_HASH_PREFIX} were found!')
+        raise ValueError(f"No sync tags starting with {CLING_TAG_ROOT_HASH_PREFIX} were found!")
     if len(rootTags) > 1:
-        raise ValueError(f'More than one sync tag were found: {str(rootTags)}!')
+        raise ValueError(f"More than one sync tag were found: {str(rootTags)}!")
     return rootTags[0]
 
+
 def getStartingRootHash(rootTag):
-    printInfo('Getting the starting ROOT Hash from the tag')
+    printInfo("Getting the starting ROOT Hash from the tag")
     prefixLen = len(CLING_TAG_ROOT_HASH_PREFIX)
     defHashLen = len(DEFAULT_STARTING_ROOT_HASH)
-    hash = rootTag[prefixLen:prefixLen+defHashLen]
+    hash = rootTag[prefixLen : prefixLen + defHashLen]
     return hash
 
-def getHashes(repoDirName, startingHash, dirInRepoName=''):
-    out = execCommand(f'git log --oneline {startingHash}..HEAD {dirInRepoName}', thisCwd=repoDirName)
+
+def getHashes(repoDirName, startingHash, dirInRepoName=""):
+    out = execCommand(f"git log --oneline {startingHash}..HEAD {dirInRepoName}", thisCwd=repoDirName)
     hashes = []
     if not out:
         return hashes
     # skip the first line since it's '\n'
-    hashes = [line.split(' ', 1)[0] for line in out.split('\n')]
+    hashes = [line.split(" ", 1)[0] for line in out.split("\n")]
     return hashes
 
+
 def createPatches(rootHashes, interpHashes):
     patches = []
 
@@ -99,49 +109,52 @@ def createPatches(rootHashes, interpHashes):
     # directory and hash is there for debugging purposes.
     for rootHashtoSync in reversed(rootHashesToSync):
         keys = []
-        if rootHashtoSync in interpHashesSet: keys.append(INTERP_DIR_NAME)
+        if rootHashtoSync in interpHashesSet:
+            keys.append(INTERP_DIR_NAME)
         for key in keys:
             patchAsStr = execCommand(f"git format-patch -1 {rootHashtoSync} {key} --stdout", ROOT_REPO_DIR_NAME)
             patches.append([key, rootHashtoSync, patchAsStr])
     return patches
 
+
 def applyPatches(patches):
     for dirInRepo, hash, patchAsStr in patches:
-        ignorePathLevel = dirInRepo.count('/') + 2
+        ignorePathLevel = dirInRepo.count("/") + 2
         destDirName = DEST_INTERP_DIR_NAME
-        directoryOption = f'--directory {destDirName}' if destDirName else ''
-        printInfo(f'Applying {hash} restricted to {dirInRepo} to repository {CLING_REPO_DIR_NAME}')
-        execCommand(f'git am -p {ignorePathLevel} {directoryOption}', CLING_REPO_DIR_NAME, patchAsStr)
+        directoryOption = f"--directory {destDirName}" if destDirName else ""
+        printInfo(f"Applying {hash} restricted to {dirInRepo} to repository {CLING_REPO_DIR_NAME}")
+        execCommand(f"git am -p {ignorePathLevel} {directoryOption}", CLING_REPO_DIR_NAME, patchAsStr)
+
 
 def syncTagAndPush(oldSyncTag, rootSyncHash):
-    '''
+    """
     Replace the tag mentioning the previous root commit to which the repo was synchronized.
     Push the changes and tags upstream.
-    '''
+    """
     # We fetch the remote and local tags to make the following operations more resilient
-    remoteTags = execCommand(f'git ls-remote --tags origin', CLING_REPO_DIR_NAME)
-    localTags = execCommand(f'git tag', CLING_REPO_DIR_NAME)
+    remoteTags = execCommand("git ls-remote --tags origin", CLING_REPO_DIR_NAME)
+    localTags = execCommand("git tag", CLING_REPO_DIR_NAME)
 
     # Clean the old tag
-    printInfo(f'Found a sync tag ({oldSyncTag}): deleting it.')
+    printInfo(f"Found a sync tag ({oldSyncTag}): deleting it.")
     if oldSyncTag in localTags:
-        execCommand(f'git tag -d {oldSyncTag}', CLING_REPO_DIR_NAME)
+        execCommand(f"git tag -d {oldSyncTag}", CLING_REPO_DIR_NAME)
     if oldSyncTag in remoteTags:
-        execCommand(f'git push --delete origin  {oldSyncTag}', CLING_REPO_DIR_NAME)
+        execCommand(f"git push --delete origin  {oldSyncTag}", CLING_REPO_DIR_NAME)
     else:
-        printWarning(f'Tag {oldSyncTag} was not found in the upstream repository.')
+        printWarning(f"Tag {oldSyncTag} was not found in the upstream repository.")
 
     # Time to push the sync commits!
-    execCommand(f'git push', CLING_REPO_DIR_NAME)
+    execCommand("git push", CLING_REPO_DIR_NAME)
 
     # And finally we tag and push the tag
-    newTag = CLING_TAG_ROOT_HASH_PREFIX+rootSyncHash
-    printInfo(f'Creating a new tag ({newTag}).')
-    execCommand(f'git tag {newTag}', CLING_REPO_DIR_NAME)
-    execCommand(f'git push origin tag {newTag}', CLING_REPO_DIR_NAME)
+    newTag = CLING_TAG_ROOT_HASH_PREFIX + rootSyncHash
+    printInfo(f"Creating a new tag ({newTag}).")
+    execCommand(f"git tag {newTag}", CLING_REPO_DIR_NAME)
+    execCommand(f"git push origin tag {newTag}", CLING_REPO_DIR_NAME)
 
-def principal():
 
+def principal():
     # We want a starting hash not to deal with the entire commit history
     # of ROOT
     rootSyncTag = getRootSyncTag()
@@ -155,29 +168,30 @@ def principal():
     # If we have no commits to sync, we quit.
     if not interpHashes:
         # nothing to do, we have no commits to sync
-        printInfo('No commit to sync. Exiting now.')
+        printInfo("No commit to sync. Exiting now.")
         return 0
 
-    printInfo(f'We found:\n - {len(interpHashes)} patches from the directory {INTERP_DIR_NAME}')
+    printInfo(f"We found:\n - {len(interpHashes)} patches from the directory {INTERP_DIR_NAME}")
 
     # We now create the patches we want to apply to the cling repo
     patches = createPatches(rootHashes, interpHashes)
 
     # We now apply the patches
     if not patches:
-        printError('No patch was distilled: this status should not be reachable')
+        printError("No patch was distilled: this status should not be reachable")
         return 1
 
     # We now need to apply patches, update the tag that mentions the ROOT commit
     # to which the cling repo was synchronised and push everything.
     # First of all we need to acquire an identity
-    printInfo('Acquiring an identity in preparation to the upstreaming of the changes')
+    printInfo("Acquiring an identity in preparation to the upstreaming of the changes")
     execCommand('git config user.email "root@persona.com"', CLING_REPO_DIR_NAME)
     execCommand('git config user.name "Root Persona"', CLING_REPO_DIR_NAME)
 
     applyPatches(patches)
 
     syncTagAndPush(rootSyncTag, rootHashes[0])
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     sys.exit(principal())