cartography 0.102.0rc1__py3-none-any.whl → 0.103.0rc1__py3-none-any.whl

cartography/intel/github/repos.py

@@ -26,11 +26,11 @@ logger = logging.getLogger(__name__)
 # - Permission: https://docs.github.com/en/graphql/reference/enums#repositorypermission
 # - Affiliation: https://docs.github.com/en/graphql/reference/enums#collaboratoraffiliation
 UserAffiliationAndRepoPermission = namedtuple(
-    'UserAffiliationAndRepoPermission',
+    "UserAffiliationAndRepoPermission",
     [
-        'user',  # Dict
-        'permission',  # 'WRITE', 'MAINTAIN', 'ADMIN', etc
-        'affiliation',  # 'OUTSIDE', 'DIRECT'
+        "user",  # Dict
+        "permission",  # 'WRITE', 'MAINTAIN', 'ADMIN', etc
+        "affiliation",  # 'OUTSIDE', 'DIRECT'
     ],
 )
 
@@ -137,28 +137,37 @@ GITHUB_REPO_COLLABS_PAGINATED_GRAPHQL = """
 
 
 def _get_repo_collaborators_inner_func(
-        org: str,
-        api_url: str,
-        token: str,
-        repo_raw_data: list[dict[str, Any]],
-        affiliation: str,
-        collab_users: list[dict[str, Any]],
-        collab_permission: list[str],
+    org: str,
+    api_url: str,
+    token: str,
+    repo_raw_data: list[dict[str, Any]],
+    affiliation: str,
+    collab_users: list[dict[str, Any]],
+    collab_permission: list[str],
 ) -> dict[str, list[UserAffiliationAndRepoPermission]]:
     result: dict[str, list[UserAffiliationAndRepoPermission]] = {}
 
     for repo in repo_raw_data:
-        repo_name = repo['name']
-        repo_url = repo['url']
-
-        if ((affiliation == 'OUTSIDE' and repo['outsideCollaborators']['totalCount'] == 0) or
-                (affiliation == 'DIRECT' and repo['directCollaborators']['totalCount'] == 0)):
+        repo_name = repo["name"]
+        repo_url = repo["url"]
+
+        if (
+            affiliation == "OUTSIDE" and repo["outsideCollaborators"]["totalCount"] == 0
+        ) or (
+            affiliation == "DIRECT" and repo["directCollaborators"]["totalCount"] == 0
+        ):
             # repo has no collabs of the affiliation type we're looking for, so don't waste time making an API call
             result[repo_url] = []
             continue
 
         logger.info(f"Loading {affiliation} collaborators for repo {repo_name}.")
-        collaborators = _get_repo_collaborators(token, api_url, org, repo_name, affiliation)
+        collaborators = _get_repo_collaborators(
+            token,
+            api_url,
+            org,
+            repo_name,
+            affiliation,
+        )
 
         # nodes and edges are expected to always be present given that we only call for them if totalCount is > 0
         # however sometimes GitHub returns None, as in issue 1334 and 1404.
@@ -167,7 +176,7 @@ def _get_repo_collaborators_inner_func(
 
         # The `or []` is because `.edges` can be None.
         for perm in collaborators.edges or []:
-            collab_permission.append(perm['permission'])
+            collab_permission.append(perm["permission"])
 
         result[repo_url] = [
             UserAffiliationAndRepoPermission(user, permission, affiliation)
@@ -177,11 +186,11 @@ def _get_repo_collaborators_inner_func(
 
 
 def _get_repo_collaborators_for_multiple_repos(
-        repo_raw_data: list[dict[str, Any]],
-        affiliation: str,
-        org: str,
-        api_url: str,
-        token: str,
+    repo_raw_data: list[dict[str, Any]],
+    affiliation: str,
+    org: str,
+    api_url: str,
+    token: str,
 ) -> dict[str, list[UserAffiliationAndRepoPermission]]:
     """
     For every repo in the given list, retrieve the collaborators.
@@ -193,7 +202,9 @@ def _get_repo_collaborators_for_multiple_repos(
     :param token: The Github API token as string.
     :return: A dictionary of repo URL to list of UserAffiliationAndRepoPermission
     """
-    logger.info(f'Retrieving repo collaborators for affiliation "{affiliation}" on org "{org}".')
+    logger.info(
+        f'Retrieving repo collaborators for affiliation "{affiliation}" on org "{org}".',
+    )
     collab_users: List[dict[str, Any]] = []
     collab_permission: List[str] = []
 
@@ -215,7 +226,11 @@ def _get_repo_collaborators_for_multiple_repos(
 
 
 def _get_repo_collaborators(
-        token: str, api_url: str, organization: str, repo: str, affiliation: str,
+    token: str,
+    api_url: str,
+    organization: str,
+    repo: str,
+    affiliation: str,
 ) -> PaginatedGraphqlData:
     """
     Retrieve a list of collaborators for a given repository, as described in
@@ -233,8 +248,8 @@ def _get_repo_collaborators(
         api_url,
         organization,
         GITHUB_REPO_COLLABS_PAGINATED_GRAPHQL,
-        'repository',
-        resource_inner_type='collaborators',
+        "repository",
+        resource_inner_type="collaborators",
         repo=repo,
         affiliation=affiliation,
     )
@@ -257,15 +272,15 @@ def get(token: str, api_url: str, organization: str) -> List[Dict]:
         api_url,
         organization,
         GITHUB_ORG_REPOS_PAGINATED_GRAPHQL,
-        'repositories',
+        "repositories",
     )
     return repos.nodes
 
 
 def transform(
-        repos_json: List[Dict],
-        direct_collaborators: dict[str, List[UserAffiliationAndRepoPermission]],
-        outside_collaborators: dict[str, List[UserAffiliationAndRepoPermission]],
+    repos_json: List[Dict],
+    direct_collaborators: dict[str, List[UserAffiliationAndRepoPermission]],
+    outside_collaborators: dict[str, List[UserAffiliationAndRepoPermission]],
 ) -> Dict:
     """
     Parses the JSON returned from GitHub API to create data for graph ingestion
@@ -283,41 +298,65 @@ def transform(
     transformed_repo_owners: List[Dict] = []
     # See https://docs.github.com/en/graphql/reference/enums#repositorypermission
     transformed_outside_collaborators: Dict[str, List[Any]] = {
-        'ADMIN': [], 'MAINTAIN': [], 'READ': [], 'TRIAGE': [], 'WRITE': [],
+        "ADMIN": [],
+        "MAINTAIN": [],
+        "READ": [],
+        "TRIAGE": [],
+        "WRITE": [],
     }
     transformed_direct_collaborators: Dict[str, List[Any]] = {
-        'ADMIN': [], 'MAINTAIN': [], 'READ': [], 'TRIAGE': [], 'WRITE': [],
+        "ADMIN": [],
+        "MAINTAIN": [],
+        "READ": [],
+        "TRIAGE": [],
+        "WRITE": [],
     }
     transformed_requirements_files: List[Dict] = []
     for repo_object in repos_json:
-        _transform_repo_languages(repo_object['url'], repo_object, transformed_repo_languages)
+        _transform_repo_languages(
+            repo_object["url"],
+            repo_object,
+            transformed_repo_languages,
+        )
         _transform_repo_objects(repo_object, transformed_repo_list)
-        _transform_repo_owners(repo_object['owner']['url'], repo_object, transformed_repo_owners)
+        _transform_repo_owners(
+            repo_object["owner"]["url"],
+            repo_object,
+            transformed_repo_owners,
+        )
 
         # Allow sync to continue if we didn't have permissions to list collaborators
-        repo_url = repo_object['url']
+        repo_url = repo_object["url"]
         if repo_url in outside_collaborators:
             _transform_collaborators(
-                repo_object['url'],
-                outside_collaborators[repo_object['url']],
+                repo_object["url"],
+                outside_collaborators[repo_object["url"]],
                 transformed_outside_collaborators,
             )
         if repo_url in direct_collaborators:
             _transform_collaborators(
-                repo_object['url'],
-                direct_collaborators[repo_object['url']],
+                repo_object["url"],
+                direct_collaborators[repo_object["url"]],
                 transformed_direct_collaborators,
             )
 
-        _transform_requirements_txt(repo_object['requirements'], repo_url, transformed_requirements_files)
-        _transform_setup_cfg_requirements(repo_object['setupCfg'], repo_url, transformed_requirements_files)
+        _transform_requirements_txt(
+            repo_object["requirements"],
+            repo_url,
+            transformed_requirements_files,
+        )
+        _transform_setup_cfg_requirements(
+            repo_object["setupCfg"],
+            repo_url,
+            transformed_requirements_files,
+        )
     results = {
-        'repos': transformed_repo_list,
-        'repo_languages': transformed_repo_languages,
-        'repo_owners': transformed_repo_owners,
-        'repo_outside_collaborators': transformed_outside_collaborators,
-        'repo_direct_collaborators': transformed_direct_collaborators,
-        'python_requirements': transformed_requirements_files,
+        "repos": transformed_repo_list,
+        "repo_languages": transformed_repo_languages,
+        "repo_owners": transformed_repo_owners,
+        "repo_outside_collaborators": transformed_outside_collaborators,
+        "repo_direct_collaborators": transformed_direct_collaborators,
+        "python_requirements": transformed_requirements_files,
     }
     return results
 
@@ -346,33 +385,37 @@ def _transform_repo_objects(input_repo_object: Dict, out_repo_list: List[Dict])
     :return: Nothing
     """
     # Create a unique ID for a GitHubBranch node representing the default branch of this repo object.
-    dbr = input_repo_object['defaultBranchRef']
-    default_branch_name = dbr['name'] if dbr else None
-    default_branch_id = _create_default_branch_id(input_repo_object['url'], dbr['id']) if dbr else None
+    dbr = input_repo_object["defaultBranchRef"]
+    default_branch_name = dbr["name"] if dbr else None
+    default_branch_id = (
+        _create_default_branch_id(input_repo_object["url"], dbr["id"]) if dbr else None
+    )
 
     # Create a git:// URL from the given SSH URL, if it exists.
-    ssh_url = input_repo_object.get('sshUrl')
+    ssh_url = input_repo_object.get("sshUrl")
     git_url = _create_git_url_from_ssh_url(ssh_url) if ssh_url else None
 
-    out_repo_list.append({
-        'id': input_repo_object['url'],
-        'createdat': input_repo_object['createdAt'],
-        'name': input_repo_object['name'],
-        'fullname': input_repo_object['nameWithOwner'],
-        'description': input_repo_object['description'],
-        'primarylanguage': input_repo_object['primaryLanguage'],
-        'homepage': input_repo_object['homepageUrl'],
-        'defaultbranch': default_branch_name,
-        'defaultbranchid': default_branch_id,
-        'private': input_repo_object['isPrivate'],
-        'disabled': input_repo_object['isDisabled'],
-        'archived': input_repo_object['isArchived'],
-        'locked': input_repo_object['isLocked'],
-        'giturl': git_url,
-        'url': input_repo_object['url'],
-        'sshurl': ssh_url,
-        'updatedat': input_repo_object['updatedAt'],
-    })
+    out_repo_list.append(
+        {
+            "id": input_repo_object["url"],
+            "createdat": input_repo_object["createdAt"],
+            "name": input_repo_object["name"],
+            "fullname": input_repo_object["nameWithOwner"],
+            "description": input_repo_object["description"],
+            "primarylanguage": input_repo_object["primaryLanguage"],
+            "homepage": input_repo_object["homepageUrl"],
+            "defaultbranch": default_branch_name,
+            "defaultbranchid": default_branch_id,
+            "private": input_repo_object["isPrivate"],
+            "disabled": input_repo_object["isDisabled"],
+            "archived": input_repo_object["isArchived"],
+            "locked": input_repo_object["isLocked"],
+            "giturl": git_url,
+            "url": input_repo_object["url"],
+            "sshurl": ssh_url,
+            "updatedat": input_repo_object["updatedAt"],
+        },
+    )
 
 
 def _transform_repo_owners(owner_id: str, repo: Dict, repo_owners: List[Dict]) -> None:
@@ -383,15 +426,21 @@ def _transform_repo_owners(owner_id: str, repo: Dict, repo_owners: List[Dict]) -
     :param repo_owners: Output array to append transformed results to.
     :return: Nothing.
     """
-    repo_owners.append({
-        'repo_id': repo['url'],
-        'owner': repo['owner']['login'],
-        'owner_id': owner_id,
-        'type': repo['owner']['__typename'],
-    })
+    repo_owners.append(
+        {
+            "repo_id": repo["url"],
+            "owner": repo["owner"]["login"],
+            "owner_id": owner_id,
+            "type": repo["owner"]["__typename"],
+        },
+    )
 
 
-def _transform_repo_languages(repo_url: str, repo: Dict, repo_languages: List[Dict]) -> None:
+def _transform_repo_languages(
+    repo_url: str,
+    repo: Dict,
+    repo_languages: List[Dict],
+) -> None:
     """
     Helper function to transform the languages in a GitHub repo.
     :param repo_url: The URL of the repo.
@@ -399,16 +448,20 @@ def _transform_repo_languages(repo_url: str, repo: Dict, repo_languages: List[Di
     :param repo_languages: Output array to append transformed results to.
     :return: Nothing.
     """
-    if repo['languages']['totalCount'] > 0:
-        for language in repo['languages']['nodes']:
-            repo_languages.append({
-                'repo_id': repo_url,
-                'language_name': language['name'],
-            })
+    if repo["languages"]["totalCount"] > 0:
+        for language in repo["languages"]["nodes"]:
+            repo_languages.append(
+                {
+                    "repo_id": repo_url,
+                    "language_name": language["name"],
+                },
+            )
 
 
 def _transform_collaborators(
-        repo_url: str, collaborators: List[UserAffiliationAndRepoPermission], transformed_collaborators: Dict,
+    repo_url: str,
+    collaborators: List[UserAffiliationAndRepoPermission],
+    transformed_collaborators: Dict,
 ) -> None:
     """
     Performs data adjustments for collaborators in a GitHub repo.
@@ -425,8 +478,8 @@ def _transform_collaborators(
     if collaborators:
         for collaborator in collaborators:
             user = collaborator.user
-            user['repo_url'] = repo_url
-            user['affiliation'] = collaborator.affiliation
+            user["repo_url"] = repo_url
+            user["affiliation"] = collaborator.affiliation
             transformed_collaborators[collaborator.permission].append(user)
 
 
@@ -442,10 +495,14 @@ def _transform_requirements_txt(
     :param out_requirements_files: Output array to append transformed results to.
     :return: Nothing.
     """
-    if req_file_contents and req_file_contents.get('text'):
-        text_contents = req_file_contents['text']
+    if req_file_contents and req_file_contents.get("text"):
+        text_contents = req_file_contents["text"]
         requirements_list = text_contents.split("\n")
-        _transform_python_requirements(requirements_list, repo_url, out_requirements_files)
+        _transform_python_requirements(
+            requirements_list,
+            repo_url,
+            out_requirements_files,
+        )
 
 
 def _transform_setup_cfg_requirements(
@@ -460,9 +517,9 @@ def _transform_setup_cfg_requirements(
     :param out_requirements_files: Output array to append transformed results to.
     :return: Nothing.
     """
-    if not setup_cfg_contents or not setup_cfg_contents.get('text'):
+    if not setup_cfg_contents or not setup_cfg_contents.get("text"):
         return
-    text_contents = setup_cfg_contents['text']
+    text_contents = setup_cfg_contents["text"]
     setup_cfg = configparser.ConfigParser()
     try:
         setup_cfg.read_string(text_contents)
@@ -490,8 +547,8 @@ def _transform_python_requirements(
     """
     parsed_list = []
     for line in requirements_list:
-        stripped_line = line.partition('#')[0].strip()
-        if stripped_line == '':
+        stripped_line = line.partition("#")[0].strip()
+        if stripped_line == "":
             continue
         try:
             req = Requirement(stripped_line)
@@ -499,7 +556,7 @@ def _transform_python_requirements(
         except InvalidRequirement:
             # INFO and not WARN/ERROR as we intentionally don't support all ways to specify Python requirements
             logger.info(
-                f"Failed to parse line \"{line}\" in repo {repo_url}'s requirements.txt; skipping line.",
+                f'Failed to parse line "{line}" in repo {repo_url}\'s requirements.txt; skipping line.',
                 exc_info=True,
             )
 
@@ -507,32 +564,44 @@ def _transform_python_requirements(
         pinned_version = None
         if len(req.specifier) == 1:
             specifier = next(iter(req.specifier))
-            if specifier.operator == '==':
+            if specifier.operator == "==":
                 pinned_version = specifier.version
 
         # Set `spec` to a default value. Example values for str(req.specifier): "<4.0,>=3.0" or "==1.0.0".
         spec: Optional[str] = str(req.specifier)
         # Set spec to `None` instead of empty string so that the Neo4j driver will leave the library.specifier field
         # undefined. As convention, we prefer undefined values over empty strings in the graph.
-        if spec == '':
+        if spec == "":
             spec = None
 
         canon_name = canonicalize_name(req.name)
-        requirement_id = f"{canon_name}|{pinned_version}" if pinned_version else canon_name
+        requirement_id = (
+            f"{canon_name}|{pinned_version}" if pinned_version else canon_name
+        )
 
-        out_requirements_files.append({
-            "id": requirement_id,
-            "name": canon_name,
-            "specifier": spec,
-            "version": pinned_version,
-            "repo_url": repo_url,
-        })
+        out_requirements_files.append(
+            {
+                "id": requirement_id,
+                "name": canon_name,
+                "specifier": spec,
+                "version": pinned_version,
+                "repo_url": repo_url,
+            },
+        )
 
 
 def parse_setup_cfg(config: configparser.ConfigParser) -> List[str]:
     reqs: List[str] = []
-    reqs.extend(_parse_setup_cfg_requirements(config.get("options", "install_requires", fallback="")))
-    reqs.extend(_parse_setup_cfg_requirements(config.get("options", "setup_requires", fallback="")))
+    reqs.extend(
+        _parse_setup_cfg_requirements(
+            config.get("options", "install_requires", fallback=""),
+        ),
+    )
+    reqs.extend(
+        _parse_setup_cfg_requirements(
+            config.get("options", "setup_requires", fallback=""),
+        ),
+    )
     if config.has_section("options.extras_require"):
         for _, val in config.items("options.extras_require"):
             reqs.extend(_parse_setup_cfg_requirements(val))
@@ -551,7 +620,11 @@ def _parse_setup_cfg_requirements(reqs: str, separator: str = ";") -> List[str]:
 
 
 @timeit
-def load_github_repos(neo4j_session: neo4j.Session, update_tag: int, repo_data: List[Dict]) -> None:
+def load_github_repos(
+    neo4j_session: neo4j.Session,
+    update_tag: int,
+    repo_data: List[Dict],
+) -> None:
     """
     Ingest the GitHub repository information
     :param neo4j_session: Neo4J session object for server communication
@@ -602,7 +675,11 @@ def load_github_repos(neo4j_session: neo4j.Session, update_tag: int, repo_data:
 
 
 @timeit
-def load_github_languages(neo4j_session: neo4j.Session, update_tag: int, repo_languages: List[Dict]) -> None:
+def load_github_languages(
+    neo4j_session: neo4j.Session,
+    update_tag: int,
+    repo_languages: List[Dict],
+) -> None:
     """
     Ingest the relationships for repo languages
     :param neo4j_session: Neo4J session object for server communication
@@ -632,7 +709,11 @@ def load_github_languages(neo4j_session: neo4j.Session, update_tag: int, repo_la
 
 
 @timeit
-def load_github_owners(neo4j_session: neo4j.Session, update_tag: int, repo_owners: List[Dict]) -> None:
+def load_github_owners(
+    neo4j_session: neo4j.Session,
+    update_tag: int,
+    repo_owners: List[Dict],
+) -> None:
     """
     Ingest the relationships for repo owners
     :param neo4j_session: Neo4J session object for server communication
@@ -641,7 +722,8 @@ def load_github_owners(neo4j_session: neo4j.Session, update_tag: int, repo_owner
     :return: Nothing
     """
     for owner in repo_owners:
-        ingest_owner_template = Template("""
+        ingest_owner_template = Template(
+            """
             MERGE (user:$account_type{id: $Id})
             ON CREATE SET user.firstseen = timestamp()
             SET user.username = $UserName,
@@ -651,22 +733,31 @@ def load_github_owners(neo4j_session: neo4j.Session, update_tag: int, repo_owner
             MATCH (repo:GitHubRepository{id: $RepoId})
             MERGE (user)<-[r:OWNER]-(repo)
             ON CREATE SET r.firstseen = timestamp()
-            SET r.lastupdated = $UpdateTag""")
+            SET r.lastupdated = $UpdateTag""",
+        )
 
-        account_type = {'User': "GitHubUser", 'Organization': "GitHubOrganization"}
+        account_type = {"User": "GitHubUser", "Organization": "GitHubOrganization"}
 
         neo4j_session.run(
-            ingest_owner_template.safe_substitute(account_type=account_type[owner['type']]),
-            Id=owner['owner_id'],
-            UserName=owner['owner'],
-            RepoId=owner['repo_id'],
+            ingest_owner_template.safe_substitute(
+                account_type=account_type[owner["type"]],
+            ),
+            Id=owner["owner_id"],
+            UserName=owner["owner"],
+            RepoId=owner["repo_id"],
             UpdateTag=update_tag,
         )
 
 
 @timeit
-def load_collaborators(neo4j_session: neo4j.Session, update_tag: int, collaborators: Dict, affiliation: str) -> None:
-    query = Template("""
+def load_collaborators(
+    neo4j_session: neo4j.Session,
+    update_tag: int,
+    collaborators: Dict,
+    affiliation: str,
+) -> None:
+    query = Template(
+        """
     UNWIND $UserData as user
 
     MERGE (u:GitHubUser{id: user.url})
@@ -683,7 +774,8 @@ def load_collaborators(neo4j_session: neo4j.Session, update_tag: int, collaborat
     MERGE (repo)<-[o:$rel_label]-(u)
     ON CREATE SET o.firstseen = timestamp()
     SET o.lastupdated = $UpdateTag
-    """)
+    """,
+    )
     for collab_type in collaborators.keys():
         relationship_label = f"{affiliation}_COLLAB_{collab_type}"
         neo4j_session.run(
@@ -694,21 +786,51 @@ def load_collaborators(neo4j_session: neo4j.Session, update_tag: int, collaborat
 
 
 @timeit
-def load(neo4j_session: neo4j.Session, common_job_parameters: Dict, repo_data: Dict) -> None:
-    load_github_repos(neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['repos'])
-    load_github_owners(neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['repo_owners'])
-    load_github_languages(neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['repo_languages'])
+def load(
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict,
+    repo_data: Dict,
+) -> None:
+    load_github_repos(
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["repos"],
+    )
+    load_github_owners(
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["repo_owners"],
+    )
+    load_github_languages(
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["repo_languages"],
+    )
     load_collaborators(
-        neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['repo_direct_collaborators'], 'DIRECT',
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["repo_direct_collaborators"],
+        "DIRECT",
     )
     load_collaborators(
-        neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['repo_outside_collaborators'], 'OUTSIDE',
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["repo_outside_collaborators"],
+        "OUTSIDE",
+    )
+    load_python_requirements(
+        neo4j_session,
+        common_job_parameters["UPDATE_TAG"],
+        repo_data["python_requirements"],
     )
-    load_python_requirements(neo4j_session, common_job_parameters['UPDATE_TAG'], repo_data['python_requirements'])
 
 
 @timeit
-def load_python_requirements(neo4j_session: neo4j.Session, update_tag: int, requirements_objects: List[Dict]) -> None:
+def load_python_requirements(
+    neo4j_session: neo4j.Session,
+    update_tag: int,
+    requirements_objects: List[Dict],
+) -> None:
     query = """
     UNWIND $Requirements AS req
         MERGE (lib:PythonLibrary:Dependency{id: req.id})
@@ -732,11 +854,11 @@ def load_python_requirements(neo4j_session: neo4j.Session, update_tag: int, requ
 
 
 def sync(
-        neo4j_session: neo4j.Session,
-        common_job_parameters: Dict[str, Any],
-        github_api_key: str,
-        github_url: str,
-        organization: str,
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict[str, Any],
+    github_api_key: str,
+    github_url: str,
+    organization: str,
 ) -> None:
     """
     Performs the sequential tasks to collect, transform, and sync github data
@@ -753,14 +875,25 @@ def sync(
     outside_collabs: dict[str, list[UserAffiliationAndRepoPermission]] = {}
     try:
         direct_collabs = _get_repo_collaborators_for_multiple_repos(
-            repos_json, "DIRECT", organization, github_url, github_api_key,
+            repos_json,
+            "DIRECT",
+            organization,
+            github_url,
+            github_api_key,
         )
         outside_collabs = _get_repo_collaborators_for_multiple_repos(
-            repos_json, "OUTSIDE", organization, github_url, github_api_key,
+            repos_json,
+            "OUTSIDE",
+            organization,
+            github_url,
+            github_api_key,
         )
     except TypeError:
         # due to permission errors or transient network error or some other nonsense
-        logger.warning('Unable to list repo collaborators due to permission errors; continuing on.', exc_info=True)
+        logger.warning(
+            "Unable to list repo collaborators due to permission errors; continuing on.",
+            exc_info=True,
+        )
     repo_data = transform(repos_json, direct_collabs, outside_collabs)
     load(neo4j_session, common_job_parameters, repo_data)
-    run_cleanup_job('github_repos_cleanup.json', neo4j_session, common_job_parameters)
+    run_cleanup_job("github_repos_cleanup.json", neo4j_session, common_job_parameters)