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

cartography/intel/aws/ecs.py

@@ -17,12 +17,15 @@ logger = logging.getLogger(__name__)
 
 @timeit
 @aws_handle_regions
-def get_ecs_cluster_arns(boto3_session: boto3.session.Session, region: str) -> List[str]:
-    client = boto3_session.client('ecs', region_name=region)
-    paginator = client.get_paginator('list_clusters')
+def get_ecs_cluster_arns(
+    boto3_session: boto3.session.Session,
+    region: str,
+) -> List[str]:
+    client = boto3_session.client("ecs", region_name=region)
+    paginator = client.get_paginator("list_clusters")
     cluster_arns: List[str] = []
     for page in paginator.paginate():
-        cluster_arns.extend(page.get('clusterArns', []))
+        cluster_arns.extend(page.get("clusterArns", []))
     return cluster_arns
 
 
@@ -33,15 +36,18 @@ def get_ecs_clusters(
     region: str,
     cluster_arns: List[str],
 ) -> List[Dict[str, Any]]:
-    client = boto3_session.client('ecs', region_name=region)
+    client = boto3_session.client("ecs", region_name=region)
     # TODO: also include attachment info, and make relationships between the attachements
     # and the cluster.
-    includes = ['SETTINGS', 'CONFIGURATIONS']
+    includes = ["SETTINGS", "CONFIGURATIONS"]
     clusters: List[Dict[str, Any]] = []
     for i in range(0, len(cluster_arns), 100):
-        cluster_arn_chunk = cluster_arns[i:i + 100]
-        cluster_chunk = client.describe_clusters(clusters=cluster_arn_chunk, include=includes)
-        clusters.extend(cluster_chunk.get('clusters', []))
+        cluster_arn_chunk = cluster_arns[i : i + 100]
+        cluster_chunk = client.describe_clusters(
+            clusters=cluster_arn_chunk,
+            include=includes,
+        )
+        clusters.extend(cluster_chunk.get("clusters", []))
     return clusters
 
 
@@ -52,40 +58,46 @@ def get_ecs_container_instances(
     boto3_session: boto3.session.Session,
     region: str,
 ) -> List[Dict[str, Any]]:
-    client = boto3_session.client('ecs', region_name=region)
-    paginator = client.get_paginator('list_container_instances')
+    client = boto3_session.client("ecs", region_name=region)
+    paginator = client.get_paginator("list_container_instances")
     container_instances: List[Dict[str, Any]] = []
     container_instance_arns: List[str] = []
     for page in paginator.paginate(cluster=cluster_arn):
-        container_instance_arns.extend(page.get('containerInstanceArns', []))
-    includes = ['CONTAINER_INSTANCE_HEALTH']
+        container_instance_arns.extend(page.get("containerInstanceArns", []))
+    includes = ["CONTAINER_INSTANCE_HEALTH"]
     for i in range(0, len(container_instance_arns), 100):
-        container_instance_arn_chunk = container_instance_arns[i:i + 100]
+        container_instance_arn_chunk = container_instance_arns[i : i + 100]
         container_instance_chunk = client.describe_container_instances(
             cluster=cluster_arn,
             containerInstances=container_instance_arn_chunk,
             include=includes,
         )
-        container_instances.extend(container_instance_chunk.get('containerInstances', []))
+        container_instances.extend(
+            container_instance_chunk.get("containerInstances", []),
+        )
     return container_instances
 
 
 @timeit
 @aws_handle_regions
-def get_ecs_services(cluster_arn: str, boto3_session: boto3.session.Session, region: str) -> List[Dict[str, Any]]:
-    client = boto3_session.client('ecs', region_name=region)
-    paginator = client.get_paginator('list_services')
+def get_ecs_services(
+    cluster_arn: str,
+    boto3_session: boto3.session.Session,
+    region: str,
+) -> List[Dict[str, Any]]:
+    client = boto3_session.client("ecs", region_name=region)
+    paginator = client.get_paginator("list_services")
     services: List[Dict[str, Any]] = []
     service_arns: List[str] = []
     for page in paginator.paginate(cluster=cluster_arn):
-        service_arns.extend(page.get('serviceArns', []))
+        service_arns.extend(page.get("serviceArns", []))
     for i in range(0, len(service_arns), 10):
-        service_arn_chunk = service_arns[i:i + 10]
+        service_arn_chunk = service_arns[i : i + 10]
         service_chunk = client.describe_services(
             cluster=cluster_arn,
             services=service_arn_chunk,
         )
-        services.extend(service_chunk.get('services', []))
+        services.extend(service_chunk.get("services", []))
     return services
 
 
@@ -96,32 +108,36 @@ def get_ecs_task_definitions(
     region: str,
     tasks: List[Dict[str, Any]],
 ) -> List[Dict[str, Any]]:
-    client = boto3_session.client('ecs', region_name=region)
+    client = boto3_session.client("ecs", region_name=region)
     task_definitions: List[Dict[str, Any]] = []
     for task in tasks:
         task_definition = client.describe_task_definition(
-            taskDefinition=task['taskDefinitionArn'],
+            taskDefinition=task["taskDefinitionArn"],
         )
-        task_definitions.append(task_definition['taskDefinition'])
+        task_definitions.append(task_definition["taskDefinition"])
     return task_definitions
 
 
 @timeit
 @aws_handle_regions
-def get_ecs_tasks(cluster_arn: str, boto3_session: boto3.session.Session, region: str) -> List[Dict[str, Any]]:
-    client = boto3_session.client('ecs', region_name=region)
-    paginator = client.get_paginator('list_tasks')
+def get_ecs_tasks(
+    cluster_arn: str,
+    boto3_session: boto3.session.Session,
+    region: str,
+) -> List[Dict[str, Any]]:
+    client = boto3_session.client("ecs", region_name=region)
+    paginator = client.get_paginator("list_tasks")
     tasks: List[Dict[str, Any]] = []
     task_arns: List[str] = []
     for page in paginator.paginate(cluster=cluster_arn):
-        task_arns.extend(page.get('taskArns', []))
+        task_arns.extend(page.get("taskArns", []))
     for i in range(0, len(task_arns), 100):
-        task_arn_chunk = task_arns[i:i + 100]
+        task_arn_chunk = task_arns[i : i + 100]
         task_chunk = client.describe_tasks(
             cluster=cluster_arn,
             tasks=task_arn_chunk,
         )
-        tasks.extend(task_chunk.get('tasks', []))
+        tasks.extend(task_chunk.get("tasks", []))
     return tasks
 
 
@@ -207,7 +223,7 @@ def load_ecs_container_instances(
     """
     instances: List[Dict[str, Any]] = []
     for instance in data:
-        instance['registeredAt'] = dict_date_to_epoch(instance, 'registeredAt')
+        instance["registeredAt"] = dict_date_to_epoch(instance, "registeredAt")
         instances.append(instance)
 
     neo4j_session.run(
@@ -269,7 +285,7 @@ def load_ecs_services(
     """  # noqa:E501
     services: List[Dict[str, Any]] = []
     for service in data:
-        service['createdAt'] = dict_date_to_epoch(service, 'createdAt')
+        service["createdAt"] = dict_date_to_epoch(service, "createdAt")
         services.append(service)
 
     neo4j_session.run(
@@ -331,8 +347,14 @@ def load_ecs_task_definitions(
     container_definitions: List[Dict[str, Any]] = []
     task_definitions: List[Dict[str, Any]] = []
     for task_definition in data:
-        task_definition['registeredAt'] = dict_date_to_epoch(task_definition, 'registeredAt')
-        task_definition['deregisteredAt'] = dict_date_to_epoch(task_definition, 'deregisteredAt')
+        task_definition["registeredAt"] = dict_date_to_epoch(
+            task_definition,
+            "registeredAt",
+        )
+        task_definition["deregisteredAt"] = dict_date_to_epoch(
+            task_definition,
+            "deregisteredAt",
+        )
         for container in task_definition.get("containerDefinitions", []):
             container["_taskDefinitionArn"] = task_definition["taskDefinitionArn"]
             container_definitions.append(container)
@@ -418,14 +440,14 @@ def load_ecs_tasks(
     containers: List[Dict[str, Any]] = []
     tasks: List[Dict[str, Any]] = []
     for task in data:
-        task['connectivityAt'] = dict_date_to_epoch(task, 'connectivityAt')
-        task['createdAt'] = dict_date_to_epoch(task, 'createdAt')
-        task['executionStoppedAt'] = dict_date_to_epoch(task, 'executionStoppedAt')
-        task['pullStartedAt'] = dict_date_to_epoch(task, 'pullStartedAt')
-        task['pullStoppedAt'] = dict_date_to_epoch(task, 'pullStoppedAt')
-        task['startedAt'] = dict_date_to_epoch(task, 'startedAt')
-        task['stoppedAt'] = dict_date_to_epoch(task, 'stoppedAt')
-        task['stoppingAt'] = dict_date_to_epoch(task, 'stoppingAt')
+        task["connectivityAt"] = dict_date_to_epoch(task, "connectivityAt")
+        task["createdAt"] = dict_date_to_epoch(task, "createdAt")
+        task["executionStoppedAt"] = dict_date_to_epoch(task, "executionStoppedAt")
+        task["pullStartedAt"] = dict_date_to_epoch(task, "pullStartedAt")
+        task["pullStoppedAt"] = dict_date_to_epoch(task, "pullStoppedAt")
+        task["startedAt"] = dict_date_to_epoch(task, "startedAt")
+        task["stoppedAt"] = dict_date_to_epoch(task, "stoppedAt")
+        task["stoppingAt"] = dict_date_to_epoch(task, "stoppingAt")
         containers.extend(task["containers"])
         tasks.append(task)
 
@@ -542,21 +564,35 @@ def load_ecs_containers(
 
 @timeit
 def cleanup_ecs(neo4j_session: neo4j.Session, common_job_parameters: Dict) -> None:
-    run_cleanup_job('aws_import_ecs_cleanup.json', neo4j_session, common_job_parameters)
+    run_cleanup_job("aws_import_ecs_cleanup.json", neo4j_session, common_job_parameters)
 
 
 @timeit
 def sync(
-    neo4j_session: neo4j.Session, boto3_session: boto3.session.Session, regions: List[str], current_aws_account_id: str,
-    update_tag: int, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.session.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict,
 ) -> None:
     for region in regions:
-        logger.info("Syncing ECS for region '%s' in account '%s'.", region, current_aws_account_id)
+        logger.info(
+            "Syncing ECS for region '%s' in account '%s'.",
+            region,
+            current_aws_account_id,
+        )
         cluster_arns = get_ecs_cluster_arns(boto3_session, region)
         clusters = get_ecs_clusters(boto3_session, region, cluster_arns)
         if len(clusters) == 0:
             continue
-        load_ecs_clusters(neo4j_session, clusters, region, current_aws_account_id, update_tag)
+        load_ecs_clusters(
+            neo4j_session,
+            clusters,
+            region,
+            current_aws_account_id,
+            update_tag,
+        )
         for cluster_arn in cluster_arns:
             cluster_instances = get_ecs_container_instances(
                 cluster_arn,

cartography/intel/aws/eks.py

@@ -18,28 +18,32 @@ logger = logging.getLogger(__name__)
 @timeit
 @aws_handle_regions
 def get_eks_clusters(boto3_session: boto3.session.Session, region: str) -> List[str]:
-    client = boto3_session.client('eks', region_name=region)
+    client = boto3_session.client("eks", region_name=region)
     clusters: List[str] = []
-    paginator = client.get_paginator('list_clusters')
+    paginator = client.get_paginator("list_clusters")
     for page in paginator.paginate():
-        clusters.extend(page['clusters'])
+        clusters.extend(page["clusters"])
     return clusters
 
 
 @timeit
-def get_eks_describe_cluster(boto3_session: boto3.session.Session, region: str, cluster_name: str) -> Dict:
-    client = boto3_session.client('eks', region_name=region)
+def get_eks_describe_cluster(
+    boto3_session: boto3.session.Session,
+    region: str,
+    cluster_name: str,
+) -> Dict:
+    client = boto3_session.client("eks", region_name=region)
     response = client.describe_cluster(name=cluster_name)
-    return response['cluster']
+    return response["cluster"]
 
 
 @timeit
 def load_eks_clusters(
-        neo4j_session: neo4j.Session,
-        cluster_data: List[Dict[str, Any]],
-        region: str,
-        current_aws_account_id: str,
-        aws_update_tag: int,
+    neo4j_session: neo4j.Session,
+    cluster_data: List[Dict[str, Any]],
+    region: str,
+    current_aws_account_id: str,
+    aws_update_tag: int,
 ) -> None:
     load(
         neo4j_session,
@@ -57,50 +61,72 @@ def _process_logging(cluster: Dict) -> bool:
     at least one entry has audit logging set to Enabled.
     """
     logging: bool = False
-    cluster_logging: Any = cluster.get('logging', {}).get('clusterLogging')
+    cluster_logging: Any = cluster.get("logging", {}).get("clusterLogging")
     if cluster_logging:
-        logging = any(filter(lambda x: 'audit' in x['types'] and x['enabled'], cluster_logging))  # type: ignore
+        logging = any(filter(lambda x: "audit" in x["types"] and x["enabled"], cluster_logging))  # type: ignore
     return logging
 
 
 @timeit
-def cleanup(neo4j_session: neo4j.Session, common_job_parameters: Dict[str, Any]) -> None:
+def cleanup(
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict[str, Any],
+) -> None:
     logger.info("Running EKS cluster cleanup")
-    GraphJob.from_node_schema(EKSClusterSchema(), common_job_parameters).run(neo4j_session)
+    GraphJob.from_node_schema(EKSClusterSchema(), common_job_parameters).run(
+        neo4j_session,
+    )
 
 
 def transform(cluster_data: Dict[str, Any]) -> List[Dict[str, Any]]:
     transformed_list = []
     for cluster_name, cluster_dict in cluster_data.items():
         transformed_dict = cluster_dict.copy()
-        transformed_dict['ClusterLogging'] = _process_logging(transformed_dict)
-        transformed_dict['ClusterEndpointPublic'] = transformed_dict.get('resourcesVpcConfig', {}).get(
-            'endpointPublicAccess',
+        transformed_dict["ClusterLogging"] = _process_logging(transformed_dict)
+        transformed_dict["ClusterEndpointPublic"] = transformed_dict.get(
+            "resourcesVpcConfig",
+            {},
+        ).get(
+            "endpointPublicAccess",
         )
-        if 'createdAt' in transformed_dict:
-            transformed_dict['created_at'] = str(transformed_dict['createdAt'])
+        if "createdAt" in transformed_dict:
+            transformed_dict["created_at"] = str(transformed_dict["createdAt"])
         transformed_list.append(transformed_dict)
     return transformed_list
 
 
 @timeit
 def sync(
-        neo4j_session: neo4j.Session,
-        boto3_session: boto3.session.Session,
-        regions: List[str],
-        current_aws_account_id: str,
-        update_tag: int,
-        common_job_parameters: Dict[str, Any],
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.session.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict[str, Any],
 ) -> None:
     for region in regions:
-        logger.info("Syncing EKS for region '%s' in account '%s'.", region, current_aws_account_id)
+        logger.info(
+            "Syncing EKS for region '%s' in account '%s'.",
+            region,
+            current_aws_account_id,
+        )
 
         clusters: List[str] = get_eks_clusters(boto3_session, region)
         cluster_data = {}
         for cluster_name in clusters:
-            cluster_data[cluster_name] = get_eks_describe_cluster(boto3_session, region, cluster_name)
+            cluster_data[cluster_name] = get_eks_describe_cluster(
+                boto3_session,
+                region,
+                cluster_name,
+            )
         transformed_list = transform(cluster_data)
 
-        load_eks_clusters(neo4j_session, transformed_list, region, current_aws_account_id, update_tag)
+        load_eks_clusters(
+            neo4j_session,
+            transformed_list,
+            region,
+            current_aws_account_id,
+            update_tag,
+        )
 
     cleanup(neo4j_session, common_job_parameters)

cartography/intel/aws/elasticache.py

@@ -17,7 +17,7 @@ stat_handler = get_stats_client(__name__)
 
 
 def _get_topic(cluster: Dict) -> Dict:
-    return cluster['NotificationConfiguration']
+    return cluster["NotificationConfiguration"]
 
 
 def transform_elasticache_topics(cluster_data: List[Dict]) -> List[Dict]:
@@ -28,7 +28,7 @@ def transform_elasticache_topics(cluster_data: List[Dict]) -> List[Dict]:
     topics: List[Dict] = []
     for cluster in cluster_data:
         topic = _get_topic(cluster)
-        topic_arn = topic['TopicArn']
+        topic_arn = topic["TopicArn"]
         if topic_arn not in seen:
             seen.add(topic_arn)
             topics.append(topic)
@@ -37,20 +37,26 @@ def transform_elasticache_topics(cluster_data: List[Dict]) -> List[Dict]:
 
 @timeit
 @aws_handle_regions
-def get_elasticache_clusters(boto3_session: boto3.session.Session, region: str) -> List[Dict]:
+def get_elasticache_clusters(
+    boto3_session: boto3.session.Session,
+    region: str,
+) -> List[Dict]:
     logger.debug(f"Getting ElastiCache Clusters in region '{region}'.")
-    client = boto3_session.client('elasticache', region_name=region)
-    paginator = client.get_paginator('describe_cache_clusters')
+    client = boto3_session.client("elasticache", region_name=region)
+    paginator = client.get_paginator("describe_cache_clusters")
     clusters: List[Dict] = []
     for page in paginator.paginate():
-        clusters.extend(page['CacheClusters'])
+        clusters.extend(page["CacheClusters"])
     return clusters
 
 
 @timeit
 def load_elasticache_clusters(
-    neo4j_session: neo4j.Session, clusters: List[Dict], region: str,
-    aws_account_id: str, update_tag: int,
+    neo4j_session: neo4j.Session,
+    clusters: List[Dict],
+    region: str,
+    aws_account_id: str,
+    update_tag: int,
 ) -> None:
     query = """
     UNWIND $clusters as elasticache_cluster
@@ -85,7 +91,9 @@ def load_elasticache_clusters(
         ON CREATE SET r2.firstseen = timestamp()
         SET r2.lastupdated = $aws_update_tag
     """
-    logger.info(f"Loading f{len(clusters)} ElastiCache clusters for region '{region}' into graph.")
+    logger.info(
+        f"Loading f{len(clusters)} ElastiCache clusters for region '{region}' into graph.",
+    )
     neo4j_session.run(
         query,
         clusters=clusters,
@@ -96,29 +104,45 @@ def load_elasticache_clusters(
 
 
 @timeit
-def cleanup(neo4j_session: neo4j.Session, current_aws_account_id: str, update_tag: int) -> None:
+def cleanup(
+    neo4j_session: neo4j.Session,
+    current_aws_account_id: str,
+    update_tag: int,
+) -> None:
     run_cleanup_job(
-        'aws_import_elasticache_cleanup.json',
+        "aws_import_elasticache_cleanup.json",
         neo4j_session,
-        {'UPDATE_TAG': update_tag, 'AWS_ID': current_aws_account_id},
+        {"UPDATE_TAG": update_tag, "AWS_ID": current_aws_account_id},
     )
 
 
 @timeit
 def sync(
-    neo4j_session: neo4j.Session, boto3_session: boto3.session.Session, regions: List[str], current_aws_account_id: str,
-    update_tag: int, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.session.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict,
 ) -> None:
     for region in regions:
-        logger.info(f"Syncing ElastiCache clusters for region '{region}' in account {current_aws_account_id}")
+        logger.info(
+            f"Syncing ElastiCache clusters for region '{region}' in account {current_aws_account_id}",
+        )
         clusters = get_elasticache_clusters(boto3_session, region)
-        load_elasticache_clusters(neo4j_session, clusters, region, current_aws_account_id, update_tag)
+        load_elasticache_clusters(
+            neo4j_session,
+            clusters,
+            region,
+            current_aws_account_id,
+            update_tag,
+        )
     cleanup(neo4j_session, current_aws_account_id, update_tag)
     merge_module_sync_metadata(
         neo4j_session,
-        group_type='AWSAccount',
+        group_type="AWSAccount",
         group_id=current_aws_account_id,
-        synced_type='ElasticacheCluster',
+        synced_type="ElasticacheCluster",
         update_tag=update_tag,
         stat_handler=stat_handler,
     )

cartography/intel/aws/elasticsearch.py

@@ -20,7 +20,7 @@ logger = logging.getLogger(__name__)
 def _get_botocore_config() -> botocore.config.Config:
     return botocore.config.Config(
         retries={
-            'max_attempts': 8,
+            "max_attempts": 8,
         },
     )
 
@@ -35,19 +35,26 @@ def _get_es_domains(client: botocore.client.BaseClient) -> List[Dict]:
     :return: list of ES domains
     """
     data = client.list_domain_names()
-    domain_names = [d['DomainName'] for d in data.get('DomainNames', [])]
+    domain_names = [d["DomainName"] for d in data.get("DomainNames", [])]
     # NOTE describe_elasticsearch_domains takes at most 5 domain names
-    domain_name_chunks = [domain_names[i:i + 5] for i in range(0, len(domain_names), 5)]
+    domain_name_chunks = [
+        domain_names[i : i + 5] for i in range(0, len(domain_names), 5)
+    ]
     domains: List[Dict] = []
     for domain_name_chunk in domain_name_chunks:
-        chunk_data = client.describe_elasticsearch_domains(DomainNames=domain_name_chunk)
-        domains.extend(chunk_data['DomainStatusList'])
+        chunk_data = client.describe_elasticsearch_domains(
+            DomainNames=domain_name_chunk,
+        )
+        domains.extend(chunk_data["DomainStatusList"])
     return domains
 
 
 @timeit
 def _load_es_domains(
-    neo4j_session: neo4j.Session, domain_list: List[Dict], aws_account_id: str, aws_update_tag: int,
+    neo4j_session: neo4j.Session,
+    domain_list: List[Dict],
+    aws_account_id: str,
+    aws_update_tag: int,
 ) -> None:
     """
     Ingest Elastic Search domains
@@ -86,7 +93,7 @@ def _load_es_domains(
     # TODO this is a hacky workaround -- neo4j doesn't accept datetime objects and this section of the object
     # TODO contains one. we really shouldn't be sending the entire object to neo4j
     for d in domain_list:
-        del d['ServiceSoftwareOptions']
+        del d["ServiceSoftwareOptions"]
 
     neo4j_session.run(
         ingest_records,
@@ -104,7 +111,10 @@ def _load_es_domains(
 
 @timeit
 def _link_es_domains_to_dns(
-    neo4j_session: neo4j.Session, domain_id: str, domain_data: Dict, aws_update_tag: int,
+    neo4j_session: neo4j.Session,
+    domain_id: str,
+    domain_data: Dict,
+    aws_update_tag: int,
 ) -> None:
     """
     Link the ES domain to its DNS FQDN endpoint and create associated nodes in the graph
@@ -117,15 +127,24 @@ def _link_es_domains_to_dns(
     # TODO add support for endpoints to this method
     if domain_data.get("Endpoint"):
         ingest_dns_record_by_fqdn(
-            neo4j_session, aws_update_tag, domain_data["Endpoint"], domain_id,
-            record_label="ESDomain", dns_node_additional_label="AWSDNSRecord",
+            neo4j_session,
+            aws_update_tag,
+            domain_data["Endpoint"],
+            domain_id,
+            record_label="ESDomain",
+            dns_node_additional_label="AWSDNSRecord",
         )
     else:
         logger.debug(f"No es endpoint data for domain id {domain_id}")
 
 
 @timeit
-def _link_es_domain_vpc(neo4j_session: neo4j.Session, domain_id: str, domain_data: Dict, aws_update_tag: int) -> None:
+def _link_es_domain_vpc(
+    neo4j_session: neo4j.Session,
+    domain_id: str,
+    domain_data: Dict,
+    aws_update_tag: int,
+) -> None:
     """
     Link the ES domain to its DNS FQDN endpoint and create associated nodes in the graph
     if needed
@@ -177,7 +196,11 @@ def _link_es_domain_vpc(neo4j_session: neo4j.Session, domain_id: str, domain_dat
 
 
 @timeit
-def _process_access_policy(neo4j_session: neo4j.Session, domain_id: str, domain_data: Dict) -> None:
+def _process_access_policy(
+    neo4j_session: neo4j.Session,
+    domain_id: str,
+    domain_data: Dict,
+) -> None:
     """
     Link the ES domain to its DNS FQDN endpoint and create associated nodes in the graph
     if needed
@@ -186,12 +209,14 @@ def _process_access_policy(neo4j_session: neo4j.Session, domain_id: str, domain_
     :param domain_id: ES domain id
     :param domain_data: domain data
     """
-    tag_es = "MATCH (es:ESDomain{id: $DomainId}) SET es.exposed_internet = $InternetExposed"
+    tag_es = (
+        "MATCH (es:ESDomain{id: $DomainId}) SET es.exposed_internet = $InternetExposed"
+    )
 
     exposed_internet = False
 
     if domain_data.get("Endpoint") and domain_data.get("AccessPolicies"):
-        policy = Policy(json.loads(domain_data['AccessPolicies']))
+        policy = Policy(json.loads(domain_data["AccessPolicies"]))
         if policy.is_internet_accessible():
             exposed_internet = True
 
@@ -201,20 +226,32 @@ def _process_access_policy(neo4j_session: neo4j.Session, domain_id: str, domain_
 @timeit
 def cleanup(neo4j_session: neo4j.Session, update_tag: int, aws_account_id: int) -> None:
     run_cleanup_job(
-        'aws_import_es_cleanup.json',
+        "aws_import_es_cleanup.json",
         neo4j_session,
-        {'UPDATE_TAG': update_tag, 'AWS_ID': aws_account_id},
+        {"UPDATE_TAG": update_tag, "AWS_ID": aws_account_id},
     )
 
 
 @timeit
 def sync(
-    neo4j_session: neo4j.Session, boto3_session: boto3.session.Session, regions: List[str], current_aws_account_id: str,
-    update_tag: int, common_job_parameters: Dict,
+    neo4j_session: neo4j.Session,
+    boto3_session: boto3.session.Session,
+    regions: List[str],
+    current_aws_account_id: str,
+    update_tag: int,
+    common_job_parameters: Dict,
 ) -> None:
     for region in regions:
-        logger.info("Syncing Elasticsearch Service for region '%s' in account '%s'.", region, current_aws_account_id)
-        client = boto3_session.client('es', region_name=region, config=_get_botocore_config())
+        logger.info(
+            "Syncing Elasticsearch Service for region '%s' in account '%s'.",
+            region,
+            current_aws_account_id,
+        )
+        client = boto3_session.client(
+            "es",
+            region_name=region,
+            config=_get_botocore_config(),
+        )
         data = _get_es_domains(client)
         _load_es_domains(neo4j_session, data, current_aws_account_id, update_tag)