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

cartography/intel/azure/storage.py

@@ -11,15 +11,19 @@ from azure.core.exceptions import HttpResponseError
 from azure.core.exceptions import ResourceNotFoundError
 from azure.mgmt.storage import StorageManagementClient
 
-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__)
 
 
 @timeit
-def get_client(credentials: Credentials, subscription_id: str) -> StorageManagementClient:
+def get_client(
+    credentials: Credentials,
+    subscription_id: str,
+) -> StorageManagementClient:
     """
     Getting the Azure Storage client
     """
@@ -28,17 +32,24 @@ def get_client(credentials: Credentials, subscription_id: str) -> StorageManagem
 
 
 @timeit
-def get_storage_account_list(credentials: Credentials, subscription_id: str) -> List[Dict]:
+def get_storage_account_list(
+    credentials: Credentials,
+    subscription_id: str,
+) -> List[Dict]:
     """
     Getting the list of storage accounts
     """
     try:
         client = get_client(credentials, subscription_id)
-        storage_account_list = list(map(lambda x: x.as_dict(), client.storage_accounts.list()))
+        storage_account_list = list(
+            map(lambda x: x.as_dict(), client.storage_accounts.list()),
+        )
 
     # ClientAuthenticationError and ResourceNotFoundError are subclasses under HttpResponseError
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving storage accounts - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving storage accounts - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Storage Account not found error - {e}")
@@ -48,16 +59,18 @@ def get_storage_account_list(credentials: Credentials, subscription_id: str) ->
         return []
 
     for storage_account in storage_account_list:
-        x = storage_account['id'].split('/')
-        storage_account['resourceGroup'] = x[x.index('resourceGroups') + 1]
+        x = storage_account["id"].split("/")
+        storage_account["resourceGroup"] = x[x.index("resourceGroups") + 1]
 
     return storage_account_list
 
 
 @timeit
 def load_storage_account_data(
-        neo4j_session: neo4j.Session, subscription_id: str, storage_account_list: List[Dict],
-        azure_update_tag: int,
+    neo4j_session: neo4j.Session,
+    subscription_id: str,
+    storage_account_list: List[Dict],
+    azure_update_tag: int,
 ) -> None:
     """
     Ingest Storage Account details into neo4j.
@@ -96,43 +109,73 @@ def load_storage_account_data(
 
 @timeit
 def sync_storage_account_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        storage_account_list: List[Dict], sync_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account_list: List[Dict],
+    sync_tag: int,
 ) -> None:
-    details = get_storage_account_details(credentials, subscription_id, storage_account_list)
-    load_storage_account_details(neo4j_session, credentials, subscription_id, details, sync_tag)
+    details = get_storage_account_details(
+        credentials,
+        subscription_id,
+        storage_account_list,
+    )
+    load_storage_account_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        details,
+        sync_tag,
+    )
 
 
 @timeit
 def get_storage_account_details(
-        credentials: Credentials, subscription_id: str, storage_account_list: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account_list: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Iterates over all Storage Accounts to get the different storage services.
     """
     for storage_account in storage_account_list:
-        queue_services = get_queue_services(credentials, subscription_id, storage_account)
-        table_services = get_table_services(credentials, subscription_id, storage_account)
+        queue_services = get_queue_services(
+            credentials,
+            subscription_id,
+            storage_account,
+        )
+        table_services = get_table_services(
+            credentials,
+            subscription_id,
+            storage_account,
+        )
         file_services = get_file_services(credentials, subscription_id, storage_account)
         blob_services = get_blob_services(credentials, subscription_id, storage_account)
-        yield storage_account['id'], storage_account['name'], storage_account[
-            'resourceGroup'
+        yield storage_account["id"], storage_account["name"], storage_account[
+            "resourceGroup"
         ], queue_services, table_services, file_services, blob_services
 
 
 @timeit
-def get_queue_services(credentials: Credentials, subscription_id: str, storage_account: Dict) -> List[Dict]:
+def get_queue_services(
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account: Dict,
+) -> List[Dict]:
     """
     Gets the list of queue services.
     """
     try:
         client = get_client(credentials, subscription_id)
         queue_service_list = client.queue_services.list(
-            storage_account['resourceGroup'], storage_account['name'],
-        ).as_dict()['value']
+            storage_account["resourceGroup"],
+            storage_account["name"],
+        ).as_dict()["value"]
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving queue services - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving queue services - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Queue services resource not found error - {e}")
@@ -145,18 +188,25 @@ def get_queue_services(credentials: Credentials, subscription_id: str, storage_a
 
 
 @timeit
-def get_table_services(credentials: Credentials, subscription_id: str, storage_account: Dict) -> List[Dict]:
+def get_table_services(
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account: Dict,
+) -> List[Dict]:
     """
     Gets the list of table services.
     """
     try:
         client = get_client(credentials, subscription_id)
         table_service_list = client.table_services.list(
-            storage_account['resourceGroup'], storage_account['name'],
-        ).as_dict()['value']
+            storage_account["resourceGroup"],
+            storage_account["name"],
+        ).as_dict()["value"]
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving table services - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving table services - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Table services resource not found error - {e}")
@@ -169,18 +219,25 @@ def get_table_services(credentials: Credentials, subscription_id: str, storage_a
 
 
 @timeit
-def get_file_services(credentials: Credentials, subscription_id: str, storage_account: Dict) -> List[Dict]:
+def get_file_services(
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account: Dict,
+) -> List[Dict]:
     """
     Gets the list of file services.
     """
     try:
         client = get_client(credentials, subscription_id)
         file_service_list = client.file_services.list(
-            storage_account['resourceGroup'], storage_account['name'],
-        ).as_dict()['value']
+            storage_account["resourceGroup"],
+            storage_account["name"],
+        ).as_dict()["value"]
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving file services - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving file services - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"File services resource not found error - {e}")
@@ -193,7 +250,11 @@ def get_file_services(credentials: Credentials, subscription_id: str, storage_ac
 
 
 @timeit
-def get_blob_services(credentials: Credentials, subscription_id: str, storage_account: Dict) -> List[Dict]:
+def get_blob_services(
+    credentials: Credentials,
+    subscription_id: str,
+    storage_account: Dict,
+) -> List[Dict]:
     """
     Gets the list of blob services.
     """
@@ -201,15 +262,18 @@ def get_blob_services(credentials: Credentials, subscription_id: str, storage_ac
         client = get_client(credentials, subscription_id)
         blob_service_list = list(
             map(
-                lambda x: x.as_dict(), client.blob_services.list(
-                    storage_account['resourceGroup'],
-                    storage_account['name'],
+                lambda x: x.as_dict(),
+                client.blob_services.list(
+                    storage_account["resourceGroup"],
+                    storage_account["name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving blob services - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving blob services - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Blob services resource not found error - {e}")
@@ -223,8 +287,11 @@ def get_blob_services(credentials: Credentials, subscription_id: str, storage_ac
 
 @timeit
 def load_storage_account_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        details: List[Tuple[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]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionaries for every Azure storage service so we can import them in a single query
@@ -234,33 +301,41 @@ def load_storage_account_details(
     file_services: List[Dict] = []
     blob_services: List[Dict] = []
 
-    for account_id, name, resourceGroup, queue_service, table_service, file_service, blob_service in details:
+    for (
+        account_id,
+        name,
+        resourceGroup,
+        queue_service,
+        table_service,
+        file_service,
+        blob_service,
+    ) in details:
         if len(queue_service) > 0:
             for service in queue_service:
-                service['storage_account_name'] = name
-                service['storage_account_id'] = account_id
-                service['resource_group_name'] = resourceGroup
+                service["storage_account_name"] = name
+                service["storage_account_id"] = account_id
+                service["resource_group_name"] = resourceGroup
             queue_services.extend(queue_service)
 
         if len(table_service) > 0:
             for service in table_service:
-                service['storage_account_name'] = name
-                service['storage_account_id'] = account_id
-                service['resource_group_name'] = resourceGroup
+                service["storage_account_name"] = name
+                service["storage_account_id"] = account_id
+                service["resource_group_name"] = resourceGroup
             table_services.extend(table_service)
 
         if len(file_service) > 0:
             for service in file_service:
-                service['storage_account_name'] = name
-                service['storage_account_id'] = account_id
-                service['resource_group_name'] = resourceGroup
+                service["storage_account_name"] = name
+                service["storage_account_id"] = account_id
+                service["resource_group_name"] = resourceGroup
             file_services.extend(file_service)
 
         if len(blob_service) > 0:
             for service in blob_service:
-                service['storage_account_name'] = name
-                service['storage_account_id'] = account_id
-                service['resource_group_name'] = resourceGroup
+                service["storage_account_name"] = name
+                service["storage_account_id"] = account_id
+                service["resource_group_name"] = resourceGroup
             blob_services.extend(blob_service)
 
     _load_queue_services(neo4j_session, queue_services, update_tag)
@@ -268,15 +343,41 @@ def load_storage_account_details(
     _load_file_services(neo4j_session, file_services, update_tag)
     _load_blob_services(neo4j_session, blob_services, update_tag)
 
-    sync_queue_services_details(neo4j_session, credentials, subscription_id, queue_services, update_tag)
-    sync_table_services_details(neo4j_session, credentials, subscription_id, table_services, update_tag)
-    sync_file_services_details(neo4j_session, credentials, subscription_id, file_services, update_tag)
-    sync_blob_services_details(neo4j_session, credentials, subscription_id, blob_services, update_tag)
+    sync_queue_services_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        queue_services,
+        update_tag,
+    )
+    sync_table_services_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        table_services,
+        update_tag,
+    )
+    sync_file_services_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        file_services,
+        update_tag,
+    )
+    sync_blob_services_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        blob_services,
+        update_tag,
+    )
 
 
 @timeit
 def _load_queue_services(
-        neo4j_session: neo4j.Session, queue_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    queue_services: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest Queue Service details into neo4j.
@@ -303,7 +404,9 @@ def _load_queue_services(
 
 @timeit
 def _load_table_services(
-        neo4j_session: neo4j.Session, table_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    table_services: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest Table Service details into neo4j.
@@ -330,7 +433,9 @@ def _load_table_services(
 
 @timeit
 def _load_file_services(
-        neo4j_session: neo4j.Session, file_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    file_services: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest File Service details into neo4j.
@@ -357,7 +462,9 @@ def _load_file_services(
 
 @timeit
 def _load_blob_services(
-        neo4j_session: neo4j.Session, blob_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    blob_services: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest Blob Service details into neo4j.
@@ -384,27 +491,40 @@ def _load_blob_services(
 
 @timeit
 def sync_queue_services_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        queue_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    queue_services: List[Dict],
+    update_tag: int,
 ) -> None:
-    queue_services_details = get_queue_services_details(credentials, subscription_id, queue_services)
+    queue_services_details = get_queue_services_details(
+        credentials,
+        subscription_id,
+        queue_services,
+    )
     load_queue_services_details(neo4j_session, queue_services_details, update_tag)
 
 
 @timeit
 def get_queue_services_details(
-        credentials: Credentials, subscription_id: str, queue_services: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    queue_services: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Returning the queues with their respective queue service id.
     """
     for queue_service in queue_services:
         queues = get_queues(credentials, subscription_id, queue_service)
-        yield queue_service['id'], queues
+        yield queue_service["id"], queues
 
 
 @timeit
-def get_queues(credentials: Credentials, subscription_id: str, queue_service: Dict) -> List[Dict]:
+def get_queues(
+    credentials: Credentials,
+    subscription_id: str,
+    queue_service: Dict,
+) -> List[Dict]:
     """
     Getting the queues from the queue service.
     """
@@ -412,9 +532,10 @@ def get_queues(credentials: Credentials, subscription_id: str, queue_service: Di
         client = get_client(credentials, subscription_id)
         queues = list(
             map(
-                lambda x: x.as_dict(), client.queue.list(
-                    queue_service['resource_group_name'],
-                    queue_service['storage_account_name'],
+                lambda x: x.as_dict(),
+                client.queue.list(
+                    queue_service["resource_group_name"],
+                    queue_service["storage_account_name"],
                 ),
             ),
         )
@@ -434,7 +555,9 @@ def get_queues(credentials: Credentials, subscription_id: str, queue_service: Di
 
 @timeit
 def load_queue_services_details(
-        neo4j_session: neo4j.Session, details: List[Tuple[Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    details: List[Tuple[Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionary for the queue so we can import them in a single query
@@ -444,14 +567,18 @@ def load_queue_services_details(
     for queue_service_id, queue in details:
         if len(queue) > 0:
             for q in queue:
-                q['service_id'] = queue_service_id
+                q["service_id"] = queue_service_id
             queues.extend(queue)
 
     _load_queues(neo4j_session, queues, update_tag)
 
 
 @timeit
-def _load_queues(neo4j_session: neo4j.Session, queues: List[Dict], update_tag: int) -> None:
+def _load_queues(
+    neo4j_session: neo4j.Session,
+    queues: List[Dict],
+    update_tag: int,
+) -> None:
     """
     Ingest Queue details into neo4j.
     """
@@ -477,27 +604,40 @@ def _load_queues(neo4j_session: neo4j.Session, queues: List[Dict], update_tag: i
 
 @timeit
 def sync_table_services_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        table_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    table_services: List[Dict],
+    update_tag: int,
 ) -> None:
-    table_services_details = get_table_services_details(credentials, subscription_id, table_services)
+    table_services_details = get_table_services_details(
+        credentials,
+        subscription_id,
+        table_services,
+    )
     load_table_services_details(neo4j_session, table_services_details, update_tag)
 
 
 @timeit
 def get_table_services_details(
-        credentials: Credentials, subscription_id: str, table_services: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    table_services: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Returning the tables with their respective table service id.
     """
     for table_service in table_services:
         tables = get_tables(credentials, subscription_id, table_service)
-        yield table_service['id'], tables
+        yield table_service["id"], tables
 
 
 @timeit
-def get_tables(credentials: Credentials, subscription_id: str, table_service: Dict) -> List[Dict]:
+def get_tables(
+    credentials: Credentials,
+    subscription_id: str,
+    table_service: Dict,
+) -> List[Dict]:
     """
     Getting the tables from the table service.
     """
@@ -505,9 +645,10 @@ def get_tables(credentials: Credentials, subscription_id: str, table_service: Di
         client = get_client(credentials, subscription_id)
         tables = list(
             map(
-                lambda x: x.as_dict(), client.table.list(
-                    table_service['resource_group_name'],
-                    table_service['storage_account_name'],
+                lambda x: x.as_dict(),
+                client.table.list(
+                    table_service["resource_group_name"],
+                    table_service["storage_account_name"],
                 ),
             ),
         )
@@ -527,7 +668,9 @@ def get_tables(credentials: Credentials, subscription_id: str, table_service: Di
 
 @timeit
 def load_table_services_details(
-        neo4j_session: neo4j.Session, details: List[Tuple[Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    details: List[Tuple[Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionary for the table so we can import them in a single query
@@ -537,14 +680,18 @@ def load_table_services_details(
     for table_service_id, table in details:
         if len(table) > 0:
             for t in table:
-                t['service_id'] = table_service_id
+                t["service_id"] = table_service_id
             tables.extend(table)
 
     _load_tables(neo4j_session, tables, update_tag)
 
 
 @timeit
-def _load_tables(neo4j_session: neo4j.Session, tables: List[Dict], update_tag: int) -> None:
+def _load_tables(
+    neo4j_session: neo4j.Session,
+    tables: List[Dict],
+    update_tag: int,
+) -> None:
     """
     Ingest Table details into neo4j.
     """
@@ -571,27 +718,40 @@ def _load_tables(neo4j_session: neo4j.Session, tables: List[Dict], update_tag: i
 
 @timeit
 def sync_file_services_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        file_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    file_services: List[Dict],
+    update_tag: int,
 ) -> None:
-    file_services_details = get_file_services_details(credentials, subscription_id, file_services)
+    file_services_details = get_file_services_details(
+        credentials,
+        subscription_id,
+        file_services,
+    )
     load_file_services_details(neo4j_session, file_services_details, update_tag)
 
 
 @timeit
 def get_file_services_details(
-        credentials: Credentials, subscription_id: str, file_services: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    file_services: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Returning the shares with their respective file service id.
     """
     for file_service in file_services:
         shares = get_shares(credentials, subscription_id, file_service)
-        yield file_service['id'], shares
+        yield file_service["id"], shares
 
 
 @timeit
-def get_shares(credentials: Credentials, subscription_id: str, file_service: Dict) -> List[Dict]:
+def get_shares(
+    credentials: Credentials,
+    subscription_id: str,
+    file_service: Dict,
+) -> List[Dict]:
     """
     Getting the shares from the file service.
     """
@@ -599,9 +759,10 @@ def get_shares(credentials: Credentials, subscription_id: str, file_service: Dic
         client = get_client(credentials, subscription_id)
         shares = list(
             map(
-                lambda x: x.as_dict(), client.file_shares.list(
-                    file_service['resource_group_name'],
-                    file_service['storage_account_name'],
+                lambda x: x.as_dict(),
+                client.file_shares.list(
+                    file_service["resource_group_name"],
+                    file_service["storage_account_name"],
                 ),
             ),
         )
@@ -621,7 +782,9 @@ def get_shares(credentials: Credentials, subscription_id: str, file_service: Dic
 
 @timeit
 def load_file_services_details(
-        neo4j_session: neo4j.Session, details: List[Tuple[Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    details: List[Tuple[Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionary for the shares so we can import them in a single query
@@ -631,14 +794,18 @@ def load_file_services_details(
     for file_service_id, share in details:
         if len(share) > 0:
             for s in share:
-                s['service_id'] = file_service_id
+                s["service_id"] = file_service_id
             shares.extend(share)
 
     _load_shares(neo4j_session, shares, update_tag)
 
 
 @timeit
-def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: int) -> None:
+def _load_shares(
+    neo4j_session: neo4j.Session,
+    shares: List[Dict],
+    update_tag: int,
+) -> None:
     """
     Ingest Share details into neo4j.
     """
@@ -675,27 +842,44 @@ def _load_shares(neo4j_session: neo4j.Session, shares: List[Dict], update_tag: i
 
 @timeit
 def sync_blob_services_details(
-        neo4j_session: neo4j.Session, credentials: Credentials, subscription_id: str,
-        blob_services: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    credentials: Credentials,
+    subscription_id: str,
+    blob_services: List[Dict],
+    update_tag: int,
 ) -> None:
-    blob_services_details = get_blob_services_details(credentials, subscription_id, blob_services)
+    blob_services_details = get_blob_services_details(
+        credentials,
+        subscription_id,
+        blob_services,
+    )
     load_blob_services_details(neo4j_session, blob_services_details, update_tag)
 
 
 @timeit
 def get_blob_services_details(
-        credentials: Credentials, subscription_id: str, blob_services: List[Dict],
+    credentials: Credentials,
+    subscription_id: str,
+    blob_services: List[Dict],
 ) -> Generator[Any, Any, Any]:
     """
     Returning the blob containers with their respective blob service id.
     """
     for blob_service in blob_services:
-        blob_containers = get_blob_containers(credentials, subscription_id, blob_service)
-        yield blob_service['id'], blob_containers
+        blob_containers = get_blob_containers(
+            credentials,
+            subscription_id,
+            blob_service,
+        )
+        yield blob_service["id"], blob_containers
 
 
 @timeit
-def get_blob_containers(credentials: Credentials, subscription_id: str, blob_service: Dict) -> List[Dict]:
+def get_blob_containers(
+    credentials: Credentials,
+    subscription_id: str,
+    blob_service: Dict,
+) -> List[Dict]:
     """
     Getting the blob containers from the blob service.
     """
@@ -705,14 +889,16 @@ def get_blob_containers(credentials: Credentials, subscription_id: str, blob_ser
             map(
                 lambda x: x.as_dict(),
                 client.blob_containers.list(
-                    blob_service['resource_group_name'],
-                    blob_service['storage_account_name'],
+                    blob_service["resource_group_name"],
+                    blob_service["storage_account_name"],
                 ),
             ),
         )
 
     except ClientAuthenticationError as e:
-        logger.warning(f"Client Authentication Error while retrieving blob containers - {e}")
+        logger.warning(
+            f"Client Authentication Error while retrieving blob containers - {e}",
+        )
         return []
     except ResourceNotFoundError as e:
         logger.warning(f"Blob containers resource not found error - {e}")
@@ -726,7 +912,9 @@ def get_blob_containers(credentials: Credentials, subscription_id: str, blob_ser
 
 @timeit
 def load_blob_services_details(
-        neo4j_session: neo4j.Session, details: List[Tuple[Any, Any]], update_tag: int,
+    neo4j_session: neo4j.Session,
+    details: List[Tuple[Any, Any]],
+    update_tag: int,
 ) -> None:
     """
     Create dictionary for the blob containers so we can import them in a single query
@@ -736,7 +924,7 @@ def load_blob_services_details(
     for blob_service_id, container in details:
         if len(container) > 0:
             for c in container:
-                c['service_id'] = blob_service_id
+                c["service_id"] = blob_service_id
             blob_containers.extend(container)
 
     _load_blob_containers(neo4j_session, blob_containers, update_tag)
@@ -744,7 +932,9 @@ def load_blob_services_details(
 
 @timeit
 def _load_blob_containers(
-        neo4j_session: neo4j.Session, blob_containers: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    blob_containers: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Ingest Blob Container details into neo4j.
@@ -783,18 +973,37 @@ def _load_blob_containers(
 
 @timeit
 def cleanup_azure_storage_accounts(
-        neo4j_session: neo4j.Session, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict,
 ) -> None:
-    run_cleanup_job('azure_storage_account_cleanup.json', neo4j_session, common_job_parameters)
+    run_cleanup_job(
+        "azure_storage_account_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 Storage for subscription '%s'.", subscription_id)
     storage_account_list = get_storage_account_list(credentials, subscription_id)
-    load_storage_account_data(neo4j_session, subscription_id, storage_account_list, sync_tag)
-    sync_storage_account_details(neo4j_session, credentials, subscription_id, storage_account_list, sync_tag)
+    load_storage_account_data(
+        neo4j_session,
+        subscription_id,
+        storage_account_list,
+        sync_tag,
+    )
+    sync_storage_account_details(
+        neo4j_session,
+        credentials,
+        subscription_id,
+        storage_account_list,
+        sync_tag,
+    )
     cleanup_azure_storage_accounts(neo4j_session, common_job_parameters)