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

cartography/intel/azure/sql.py

@@ -14,10 +14,11 @@ from azure.mgmt.sql.models import SecurityAlertPolicyName
 from azure.mgmt.sql.models import TransparentDataEncryptionName
 from msrestazure.azure_exceptions import CloudError
 
-from .util.credentials import Credentials
 from cartography.util import run_cleanup_job
 from cartography.util import timeit
 
+from .util.credentials import Credentials
+
 logger = logging.getLogger(__name__)
 
 
@@ -51,16 +52,18 @@ def get_server_list(credentials: Credentials, subscription_id: str) -> List[Dict
         return []
 
     for server in server_list:
-        x = server['id'].split('/')
-        server['resourceGroup'] = x[x.index('resourceGroups') + 1]
+        x = server["id"].split("/")
+        server["resourceGroup"] = x[x.index("resourceGroups") + 1]
 
     return server_list
 
 
 @timeit
 def load_server_data(
-        neo4j_session: neo4j.Session, subscription_id: str, server_list: List[Dict],
-        azure_update_tag: int,
+    neo4j_session: neo4j.Session,
+    subscription_id: str,
+    server_list: List[Dict],
+    azure_update_tag: int,
 ) -> None:
     """
     Ingest the server details into neo4j.
@@ -92,8 +95,11 @@ def load_server_data(
 
 @timeit
 def sync_server_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        server_list: List[Dict], sync_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    server_list: List[Dict],
+    sync_tag: int,
 ) -> None:
     details = get_server_details(credentials, subscription_id, server_list)
     load_server_details(neo4j_session, credentials, subscription_id, details, sync_tag)  # type: ignore
@@ -101,7 +107,9 @@ def sync_server_details(
 
 @timeit
 def get_server_details(
-        credentials: Credentials, subscription_id: str, server_list: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    server_list: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Iterate over each servers to get its resource details.
@@ -110,17 +118,25 @@ def get_server_details(
         dns_alias = get_dns_aliases(credentials, subscription_id, server)
         ad_admins = get_ad_admins(credentials, subscription_id, server)
         r_databases = get_recoverable_databases(credentials, subscription_id, server)
-        rd_databases = get_restorable_dropped_databases(credentials, subscription_id, server)
+        rd_databases = get_restorable_dropped_databases(
+            credentials,
+            subscription_id,
+            server,
+        )
         fgs = get_failover_groups(credentials, subscription_id, server)
         elastic_pools = get_elastic_pools(credentials, subscription_id, server)
         databases = get_databases(credentials, subscription_id, server)
-        yield server['id'], server['name'], server[
-            'resourceGroup'
+        yield server["id"], server["name"], server[
+            "resourceGroup"
         ], dns_alias, ad_admins, r_databases, rd_databases, fgs, elastic_pools, databases
 
 
 @timeit
-def get_dns_aliases(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_dns_aliases(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of the DNS aliases in a server.
     """
@@ -129,12 +145,17 @@ def get_dns_aliases(credentials: Credentials, subscription_id: str, server: Dict
         dns_aliases = list(
             map(
                 lambda x: x.as_dict(),
-                client.server_dns_aliases.list_by_server(server['resourceGroup'], server['name']),
+                client.server_dns_aliases.list_by_server(
+                    server["resourceGroup"],
+                    server["name"],
+                ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving DNS Aliases - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving DNS Aliases - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"DNS Alias resource not found error - {e}")
@@ -147,7 +168,11 @@ def get_dns_aliases(credentials: Credentials, subscription_id: str, server: Dict
 
 
 @timeit
-def get_ad_admins(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_ad_admins(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of the Server AD Administrators in a server.
     """
@@ -157,14 +182,16 @@ def get_ad_admins(credentials: Credentials, subscription_id: str, server: Dict)
             map(
                 lambda x: x.as_dict(),
                 client.server_azure_ad_administrators.list_by_server(
-                    server['resourceGroup'],
-                    server['name'],
+                    server["resourceGroup"],
+                    server["name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving Azure AD Administrators - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving Azure AD Administrators - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Azure AD Administrators resource not found error - {e}")
@@ -177,7 +204,11 @@ def get_ad_admins(credentials: Credentials, subscription_id: str, server: Dict)
 
 
 @timeit
-def get_recoverable_databases(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_recoverable_databases(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of the Recoverable databases in a server.
     """
@@ -187,8 +218,8 @@ def get_recoverable_databases(credentials: Credentials, subscription_id: str, se
             map(
                 lambda x: x.as_dict(),
                 client.recoverable_databases.list_by_server(
-                    server['resourceGroup'],
-                    server['name'],
+                    server["resourceGroup"],
+                    server["name"],
                 ),
             ),
         )
@@ -197,7 +228,9 @@ def get_recoverable_databases(credentials: Credentials, subscription_id: str, se
         # The API returns a '404 CloudError: Not Found for url: <url>' if no recoverable databases are present.
         return []
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving recoverable databases - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving recoverable databases - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Recoverable databases resource not found error - {e}")
@@ -210,7 +243,11 @@ def get_recoverable_databases(credentials: Credentials, subscription_id: str, se
 
 
 @timeit
-def get_restorable_dropped_databases(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_restorable_dropped_databases(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of the Restorable Dropped Databases in a server.
     """
@@ -220,13 +257,16 @@ def get_restorable_dropped_databases(credentials: Credentials, subscription_id:
             map(
                 lambda x: x.as_dict(),
                 client.restorable_dropped_databases.list_by_server(
-                    server['resourceGroup'], server['name'],
+                    server["resourceGroup"],
+                    server["name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving Restorable Dropped Databases - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving Restorable Dropped Databases - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Restorable Dropped Databases resource not found error - {e}")
@@ -239,18 +279,30 @@ def get_restorable_dropped_databases(credentials: Credentials, subscription_id:
 
 
 @timeit
-def get_failover_groups(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_failover_groups(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of Failover groups in a server.
     """
     try:
         client = get_client(credentials, subscription_id)
         failover_groups = list(
-            map(lambda x: x.as_dict(), client.failover_groups.list_by_server(server['resourceGroup'], server['name'])),
+            map(
+                lambda x: x.as_dict(),
+                client.failover_groups.list_by_server(
+                    server["resourceGroup"],
+                    server["name"],
+                ),
+            ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving Failover groups - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving Failover groups - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Failover groups resource not found error - {e}")
@@ -263,18 +315,30 @@ def get_failover_groups(credentials: Credentials, subscription_id: str, server:
 
 
 @timeit
-def get_elastic_pools(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_elastic_pools(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of Elastic Pools in a server.
     """
     try:
         client = get_client(credentials, subscription_id)
         elastic_pools = list(
-            map(lambda x: x.as_dict(), client.elastic_pools.list_by_server(server['resourceGroup'], server['name'])),
+            map(
+                lambda x: x.as_dict(),
+                client.elastic_pools.list_by_server(
+                    server["resourceGroup"],
+                    server["name"],
+                ),
+            ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving Elastic Pools - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving Elastic Pools - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Elastic Pools resource not found error - {e}")
@@ -287,18 +351,30 @@ def get_elastic_pools(credentials: Credentials, subscription_id: str, server: Di
 
 
 @timeit
-def get_databases(credentials: Credentials, subscription_id: str, server: Dict) -> List[Dict]:
+def get_databases(
+    credentials: Credentials,
+    subscription_id: str,
+    server: Dict,
+) -> List[Dict]:
     """
     Returns details of Databases in a SQL server.
     """
     try:
         client = get_client(credentials, subscription_id)
         databases = list(
-            map(lambda x: x.as_dict(), client.databases.list_by_server(server['resourceGroup'], server['name'])),
+            map(
+                lambda x: x.as_dict(),
+                client.databases.list_by_server(
+                    server["resourceGroup"],
+                    server["name"],
+                ),
+            ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving SQL databases - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving SQL databases - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"SQL databases resource not found error - {e}")
@@ -312,8 +388,11 @@ def get_databases(credentials: Credentials, subscription_id: str, server: Dict)
 
 @timeit
 def load_server_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        details: List[Tuple[Any, Any, Any, Any, Any, Any, Any, Any, Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    details: List[Tuple[Any, Any, Any, Any, Any, Any, Any, Any, Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionaries for every resource in the server so we can import them in a single query
@@ -326,64 +405,87 @@ def load_server_details(
     elastic_pools = []
     databases = []
 
-    for server_id, name, rg, dns_alias, ad_admin, r_database, rd_database, fg, elastic_pool, database in details:
+    for (
+        server_id,
+        name,
+        rg,
+        dns_alias,
+        ad_admin,
+        r_database,
+        rd_database,
+        fg,
+        elastic_pool,
+        database,
+    ) in details:
         if len(dns_alias) > 0:
             for alias in dns_alias:
-                alias['server_name'] = name
-                alias['server_id'] = server_id
+                alias["server_name"] = name
+                alias["server_id"] = server_id
                 dns_aliases.append(alias)
 
         if len(ad_admin) > 0:
             for admin in ad_admin:
-                admin['server_name'] = name
-                admin['server_id'] = server_id
+                admin["server_name"] = name
+                admin["server_id"] = server_id
                 ad_admins.append(admin)
 
         if len(r_database) > 0:
             for rdb in r_database:
-                rdb['server_name'] = name
-                rdb['server_id'] = server_id
+                rdb["server_name"] = name
+                rdb["server_id"] = server_id
                 recoverable_databases.append(rdb)
 
         if len(rd_database) > 0:
             for rddb in rd_database:
-                rddb['server_name'] = name
-                rddb['server_id'] = server_id
+                rddb["server_name"] = name
+                rddb["server_id"] = server_id
                 restorable_dropped_databases.append(rddb)
 
         if len(fg) > 0:
             for group in fg:
-                group['server_name'] = name
-                group['server_id'] = server_id
+                group["server_name"] = name
+                group["server_id"] = server_id
                 failover_groups.append(group)
 
         if len(elastic_pool) > 0:
             for pool in elastic_pool:
-                pool['server_name'] = name
-                pool['server_id'] = server_id
+                pool["server_name"] = name
+                pool["server_id"] = server_id
                 elastic_pools.append(pool)
 
         if len(database) > 0:
             for db in database:
-                db['server_name'] = name
-                db['server_id'] = server_id
-                db['resource_group_name'] = rg
+                db["server_name"] = name
+                db["server_id"] = server_id
+                db["resource_group_name"] = rg
                 databases.append(db)
 
     _load_server_dns_aliases(neo4j_session, dns_aliases, update_tag)
     _load_server_ad_admins(neo4j_session, ad_admins, update_tag)
     _load_recoverable_databases(neo4j_session, recoverable_databases, update_tag)
-    _load_restorable_dropped_databases(neo4j_session, restorable_dropped_databases, update_tag)
+    _load_restorable_dropped_databases(
+        neo4j_session,
+        restorable_dropped_databases,
+        update_tag,
+    )
     _load_failover_groups(neo4j_session, failover_groups, update_tag)
     _load_elastic_pools(neo4j_session, elastic_pools, update_tag)
     _load_databases(neo4j_session, databases, update_tag)
 
-    sync_database_details(neo4j_session, credentials, subscription_id, databases, update_tag)
+    sync_database_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        databases,
+        update_tag,
+    )
 
 
 @timeit
 def _load_server_dns_aliases(
-        neo4j_session: neo4j.Session, dns_aliases: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    dns_aliases: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the DNS Alias details into neo4j.
@@ -411,7 +513,9 @@ def _load_server_dns_aliases(
 
 @timeit
 def _load_server_ad_admins(
-        neo4j_session: neo4j.Session, ad_admins: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    ad_admins: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the Server AD Administrators details into neo4j.
@@ -440,7 +544,9 @@ def _load_server_ad_admins(
 
 @timeit
 def _load_recoverable_databases(
-        neo4j_session: neo4j.Session, recoverable_databases: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    recoverable_databases: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the recoverable database details into neo4j.
@@ -470,7 +576,9 @@ def _load_recoverable_databases(
 
 @timeit
 def _load_restorable_dropped_databases(
-        neo4j_session: neo4j.Session, restorable_dropped_databases: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    restorable_dropped_databases: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the restorable dropped database details into neo4j.
@@ -504,7 +612,9 @@ def _load_restorable_dropped_databases(
 
 @timeit
 def _load_failover_groups(
-        neo4j_session: neo4j.Session, failover_groups: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    failover_groups: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the failover groups details into neo4j.
@@ -533,7 +643,9 @@ def _load_failover_groups(
 
 @timeit
 def _load_elastic_pools(
-        neo4j_session: neo4j.Session, elastic_pools: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    elastic_pools: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the elastic pool details into neo4j.
@@ -566,7 +678,9 @@ def _load_elastic_pools(
 
 @timeit
 def _load_databases(
-        neo4j_session: neo4j.Session, databases: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    databases: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest the database details into neo4j.
@@ -605,8 +719,11 @@ def _load_databases(
 
 @timeit
 def sync_database_details(
-        neo4j_session: neo4j.Session, credentials: Credentials,
-        subscription_id: str, databases: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    databases: List[Dict],
+    update_tag: int,
 ) -> None:
     db_details = get_database_details(credentials, subscription_id, databases)
     load_database_details(neo4j_session, db_details, update_tag)  # type: ignore
@@ -614,23 +731,41 @@ def sync_database_details(
 
 @timeit
 def get_database_details(
-        credentials: Credentials, subscription_id: str, databases: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    databases: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Iterate over the databases to get the details of resources in it.
     """
     for database in databases:
-        replication_links = get_replication_links(credentials, subscription_id, database)
-        db_threat_detection_policies = get_db_threat_detection_policies(credentials, subscription_id, database)
+        replication_links = get_replication_links(
+            credentials,
+            subscription_id,
+            database,
+        )
+        db_threat_detection_policies = get_db_threat_detection_policies(
+            credentials,
+            subscription_id,
+            database,
+        )
         restore_points = get_restore_points(credentials, subscription_id, database)
-        transparent_data_encryptions = get_transparent_data_encryptions(credentials, subscription_id, database)
+        transparent_data_encryptions = get_transparent_data_encryptions(
+            credentials,
+            subscription_id,
+            database,
+        )
         yield database[
-            'id'
+            "id"
         ], replication_links, db_threat_detection_policies, restore_points, transparent_data_encryptions
 
 
 @timeit
-def get_replication_links(credentials: Credentials, subscription_id: str, database: Dict) -> List[Dict]:
+def get_replication_links(
+    credentials: Credentials,
+    subscription_id: str,
+    database: Dict,
+) -> List[Dict]:
     """
     Returns the details of replication links in a database.
     """
@@ -640,15 +775,17 @@ def get_replication_links(credentials: Credentials, subscription_id: str, databa
             map(
                 lambda x: x.as_dict(),
                 client.replication_links.list_by_database(
-                    database['resource_group_name'],
-                    database['server_name'],
-                    database['name'],
+                    database["resource_group_name"],
+                    database["server_name"],
+                    database["name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving replication links - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving replication links - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Replication links resource not found error - {e}")
@@ -661,33 +798,45 @@ def get_replication_links(credentials: Credentials, subscription_id: str, databa
 
 
 @timeit
-def get_db_threat_detection_policies(credentials: Credentials, subscription_id: str, database: Dict) -> List[Dict]:
+def get_db_threat_detection_policies(
+    credentials: Credentials,
+    subscription_id: str,
+    database: Dict,
+) -> List[Dict]:
     """
     Returns the threat detection policy of a database.
     """
     try:
         client = get_client(credentials, subscription_id)
         db_threat_detection_policies = client.database_threat_detection_policies.get(
-            database['resource_group_name'],
-            database['server_name'],
-            database['name'],
+            database["resource_group_name"],
+            database["server_name"],
+            database["name"],
             SecurityAlertPolicyName.DEFAULT,
         ).as_dict()
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving threat detection policy - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving threat detection policy - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Threat detection policy resource not found error - {e}")
         return []
     except HttpResponseError as e:
-        logger.warning(f"Error while retrieving database threat detection policies - {e}")
+        logger.warning(
+            f"Error while retrieving database threat detection policies - {e}",
+        )
         return []
 
     return db_threat_detection_policies
 
 
 @timeit
-def get_restore_points(credentials: Credentials, subscription_id: str, database: Dict) -> List[Dict]:
+def get_restore_points(
+    credentials: Credentials,
+    subscription_id: str,
+    database: Dict,
+) -> List[Dict]:
     """
     Returns the details of restore points in a database.
     """
@@ -697,15 +846,17 @@ def get_restore_points(credentials: Credentials, subscription_id: str, database:
             map(
                 lambda x: x.as_dict(),
                 client.restore_points.list_by_database(
-                    database['resource_group_name'],
-                    database['server_name'],
-                    database['name'],
+                    database["resource_group_name"],
+                    database["server_name"],
+                    database["name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving restore points - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving restore points - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Restore points resource not found error - {e}")
@@ -718,20 +869,26 @@ def get_restore_points(credentials: Credentials, subscription_id: str, database:
 
 
 @timeit
-def get_transparent_data_encryptions(credentials: Credentials, subscription_id: str, database: Dict) -> List[Dict]:
+def get_transparent_data_encryptions(
+    credentials: Credentials,
+    subscription_id: str,
+    database: Dict,
+) -> List[Dict]:
     """
     Returns the details of transparent data encryptions in a database.
     """
     try:
         client = get_client(credentials, subscription_id)
         transparent_data_encryptions_list = client.transparent_data_encryptions.get(
-            database['resource_group_name'],
-            database['server_name'],
-            database['name'],
+            database["resource_group_name"],
+            database["server_name"],
+            database["name"],
             TransparentDataEncryptionName.CURRENT,
         ).as_dict()
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving transparent data encryptions - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving transparent data encryptions - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Transparent data encryptions resource not found error - {e}")
@@ -745,7 +902,9 @@ def get_transparent_data_encryptions(credentials: Credentials, subscription_id:
 
 @timeit
 def load_database_details(
-        neo4j_session: neo4j.Session, details: List[Tuple[Any, Any, Any, Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    details: List[Tuple[Any, Any, Any, Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionaries for every resource in a database so we can import them in a single query
@@ -755,34 +914,46 @@ def load_database_details(
     restore_points = []
     encryptions_list = []
 
-    for databaseId, replication_link, db_threat_detection_policy, restore_point, transparent_data_encryption in details:
+    for (
+        databaseId,
+        replication_link,
+        db_threat_detection_policy,
+        restore_point,
+        transparent_data_encryption,
+    ) in details:
         if len(replication_link) > 0:
             for link in replication_link:
-                link['database_id'] = databaseId
+                link["database_id"] = databaseId
                 replication_links.append(link)
 
         if len(db_threat_detection_policy) > 0:
-            db_threat_detection_policy['database_id'] = databaseId
+            db_threat_detection_policy["database_id"] = databaseId
             threat_detection_policies.append(db_threat_detection_policy)
 
         if len(restore_point) > 0:
             for point in restore_point:
-                point['database_id'] = databaseId
+                point["database_id"] = databaseId
                 restore_points.append(point)
 
         if len(transparent_data_encryption) > 0:
-            transparent_data_encryption['database_id'] = databaseId
+            transparent_data_encryption["database_id"] = databaseId
             encryptions_list.append(transparent_data_encryption)
 
     _load_replication_links(neo4j_session, replication_links, update_tag)
-    _load_db_threat_detection_policies(neo4j_session, threat_detection_policies, update_tag)
+    _load_db_threat_detection_policies(
+        neo4j_session,
+        threat_detection_policies,
+        update_tag,
+    )
     _load_restore_points(neo4j_session, restore_points, update_tag)
     _load_transparent_data_encryptions(neo4j_session, encryptions_list, update_tag)
 
 
 @timeit
 def _load_replication_links(
-        neo4j_session: neo4j.Session, replication_links: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    replication_links: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest replication links into neo4j.
@@ -820,7 +991,9 @@ def _load_replication_links(
 
 @timeit
 def _load_db_threat_detection_policies(
-        neo4j_session: neo4j.Session, threat_detection_policies: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    threat_detection_policies: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest threat detection policy into neo4j.
@@ -857,7 +1030,9 @@ def _load_db_threat_detection_policies(
 
 @timeit
 def _load_restore_points(
-        neo4j_session: neo4j.Session, restore_points: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    restore_points: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest restore points into neo4j.
@@ -888,7 +1063,9 @@ def _load_restore_points(
 
 @timeit
 def _load_transparent_data_encryptions(
-        neo4j_session: neo4j.Session, encryptions_list: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    encryptions_list: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest transparent data encryptions into neo4j.
@@ -917,18 +1094,32 @@ def _load_transparent_data_encryptions(
 
 @timeit
 def cleanup_azure_sql_servers(
-        neo4j_session: neo4j.Session, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict,
 ) -> None:
-    run_cleanup_job('azure_sql_server_cleanup.json', neo4j_session, common_job_parameters)
+    run_cleanup_job(
+        "azure_sql_server_cleanup.json",
+        neo4j_session,
+        common_job_parameters,
+    )
 
 
 @timeit
 def sync(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        sync_tag: int, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    sync_tag: int,
+    common_job_parameters: Dict,
 ) -> None:
     logger.info("Syncing Azure SQL for subscription '%s'.", subscription_id)
     server_list = get_server_list(credentials, subscription_id)
     load_server_data(neo4j_session, subscription_id, server_list, sync_tag)
-    sync_server_details(neo4j_session, credentials, subscription_id, server_list, sync_tag)
+    sync_server_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        server_list,
+        sync_tag,
+    )
     cleanup_azure_sql_servers(neo4j_session, common_job_parameters)