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

cartography/intel/openai/util.py

@@ -0,0 +1,29 @@
+from typing import Any
+from typing import Generator
+
+import requests
+
+
+def paginated_get(
+    api_session: requests.Session,
+    url: str,
+    timeout: tuple[int, int],
+    after: str | None = None,
+) -> Generator[dict[str, Any], None, None]:
+    # DOC
+    params = {"after": after} if after else {}
+    req = api_session.get(
+        url,
+        params=params,
+        timeout=timeout,
+    )
+    req.raise_for_status()
+    result = req.json()
+    yield from result.get("data", [])
+    if result.get("has_more"):
+        yield from paginated_get(
+            api_session,
+            url,
+            timeout=timeout,
+            after=result.get("last_id"),
+        )

cartography/intel/pagerduty/__init__.py

@@ -4,9 +4,7 @@ import neo4j
 from pdpyras import APISession
 
 from cartography.config import Config
-from cartography.intel.pagerduty.escalation_policies import (
-    sync_escalation_policies,
-)
+from cartography.intel.pagerduty.escalation_policies import sync_escalation_policies
 from cartography.intel.pagerduty.schedules import sync_schedules
 from cartography.intel.pagerduty.services import sync_services
 from cartography.intel.pagerduty.teams import sync_teams
@@ -23,7 +21,8 @@ stat_handler = get_stats_client(__name__)
 
 @timeit
 def start_pagerduty_ingestion(
-    neo4j_session: neo4j.Session, config: Config,
+    neo4j_session: neo4j.Session,
+    config: Config,
 ) -> None:
     """
     Perform ingestion of pagerduty data.
@@ -35,7 +34,9 @@ def start_pagerduty_ingestion(
         "UPDATE_TAG": config.update_tag,
     }
     if not config.pagerduty_api_key:
-        logger.info('PagerDuty import is not configured - skipping this module. See docs to configure.')
+        logger.info(
+            "PagerDuty import is not configured - skipping this module. See docs to configure.",
+        )
         return
     session = APISession(config.pagerduty_api_key)
     if config.pagerduty_request_timeout is not None:
@@ -54,8 +55,8 @@ def start_pagerduty_ingestion(
 
     merge_module_sync_metadata(
         neo4j_session,
-        group_type='pagerduty',
-        group_id='module',
+        group_type="pagerduty",
+        group_id="module",
         synced_type="pagerduty",
         update_tag=config.update_tag,
         stat_handler=stat_handler,

cartography/intel/pagerduty/escalation_policies.py

@@ -31,7 +31,9 @@ def get_escalation_policies(pd_session: APISession) -> List[Dict[str, Any]]:
 
 
 def load_escalation_policy_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load escalation_policy information
@@ -82,7 +84,9 @@ def load_escalation_policy_data(
 
 
 def _attach_rules(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add escalation policy rules, and attach them to targets.
@@ -122,7 +126,9 @@ def _attach_rules(
 
 
 def _attach_user_targets(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between escalation policy and services.
@@ -142,7 +148,9 @@ def _attach_user_targets(
 
 
 def _attach_schedule_targets(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between escalation policy and services.
@@ -162,7 +170,9 @@ def _attach_schedule_targets(
 
 
 def _attach_services(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between escalation policy and services.
@@ -182,7 +192,9 @@ def _attach_services(
 
 
 def _attach_teams(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between escalation policy and teams.

cartography/intel/pagerduty/schedules.py

@@ -32,7 +32,9 @@ def get_schedules(pd_session: APISession) -> List[Dict[str, Any]]:
 
 
 def load_schedule_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load schedule information
@@ -72,7 +74,9 @@ def load_schedule_data(
 
 
 def _attach_users(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between schedule and users.
@@ -91,7 +95,9 @@ def _attach_users(
 
 
 def _attach_layers(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Create layers for a schedule and attach them together
@@ -133,7 +139,9 @@ def _attach_layers(
 
 
 def _attach_layer_users(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between schedule layers and users.

cartography/intel/pagerduty/services.py

@@ -34,7 +34,8 @@ def get_services(pd_session: APISession) -> List[Dict[str, Any]]:
 
 @timeit
 def get_integrations(
-    pd_session: APISession, services: List[Dict[str, Any]],
+    pd_session: APISession,
+    services: List[Dict[str, Any]],
 ) -> List[Dict[str, Any]]:
     """
     Get integrations from services.
@@ -51,7 +52,9 @@ def get_integrations(
 
 
 def load_service_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load service information
@@ -104,7 +107,9 @@ def load_service_data(
 
 
 def _attach_teams(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Add relationship between teams and services.
@@ -123,7 +128,9 @@ def _attach_teams(
 
 
 def load_integration_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load integration information

cartography/intel/pagerduty/teams.py

@@ -33,7 +33,8 @@ def get_teams(pd_session: APISession) -> List[Dict[str, Any]]:
 
 @timeit
 def get_team_members(
-    pd_session: APISession, teams: List[Dict[str, Any]],
+    pd_session: APISession,
+    teams: List[Dict[str, Any]],
 ) -> List[Dict[str, str]]:
     relations: List[Dict[str, str]] = []
     for team in teams:
@@ -46,7 +47,9 @@ def get_team_members(
 
 
 def load_team_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load teamuser information
@@ -73,7 +76,9 @@ def load_team_data(
 
 
 def load_team_relations(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Attach users to their teams

cartography/intel/pagerduty/users.py

@@ -30,7 +30,9 @@ def get_users(pd_session: APISession) -> List[Dict[str, Any]]:
 
 
 def load_user_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load user information

cartography/intel/pagerduty/vendors.py

@@ -30,7 +30,9 @@ def get_vendors(pd_session: APISession) -> List[Dict[str, Any]]:
 
 
 def load_vendor_data(
-    neo4j_session: neo4j.Session, data: List[Dict], update_tag: int,
+    neo4j_session: neo4j.Session,
+    data: List[Dict],
+    update_tag: int,
 ) -> None:
     """
     Transform and load vendor information

cartography/intel/semgrep/__init__.py

@@ -8,23 +8,41 @@ from cartography.intel.semgrep.deployment import sync_deployment
 from cartography.intel.semgrep.findings import sync_findings
 from cartography.util import timeit
 
-
 logger = logging.getLogger(__name__)
 
 
 @timeit
 def start_semgrep_ingestion(
-    neo4j_session: neo4j.Session, config: Config,
+    neo4j_session: neo4j.Session,
+    config: Config,
 ) -> None:
     common_job_parameters = {
         "UPDATE_TAG": config.update_tag,
     }
     if not config.semgrep_app_token:
-        logger.info('Semgrep import is not configured - skipping this module. See docs to configure.')
+        logger.info(
+            "Semgrep import is not configured - skipping this module. See docs to configure.",
+        )
         return
 
     # sync_deployment must be called first since it populates common_job_parameters
     # with the deployment ID and slug, which are required by the other sync functions
-    sync_deployment(neo4j_session, config.semgrep_app_token, config.update_tag, common_job_parameters)
-    sync_dependencies(neo4j_session, config.semgrep_app_token, config.semgrep_dependency_ecosystems, config.update_tag, common_job_parameters)  # noqa: E501
-    sync_findings(neo4j_session, config.semgrep_app_token, config.update_tag, common_job_parameters)
+    sync_deployment(
+        neo4j_session,
+        config.semgrep_app_token,
+        config.update_tag,
+        common_job_parameters,
+    )
+    sync_dependencies(
+        neo4j_session,
+        config.semgrep_app_token,
+        config.semgrep_dependency_ecosystems,
+        config.update_tag,
+        common_job_parameters,
+    )  # noqa: E501
+    sync_findings(
+        neo4j_session,
+        config.semgrep_app_token,
+        config.update_tag,
+        common_job_parameters,
+    )

cartography/intel/semgrep/dependencies.py

@@ -26,30 +26,34 @@ _MAX_RETRIES = 3
 # The keys in this dictionary must be in Semgrep's list of supported ecosystems, defined here:
 # https://semgrep.dev/api/v1/docs/#tag/SupplyChainService/operation/semgrep_app.products.sca.handlers.dependency.list_dependencies_conexxion
 ECOSYSTEM_TO_SCHEMA: Dict = {
-    'gomod': SemgrepGoLibrarySchema,
-    'npm': SemgrepNpmLibrarySchema,
+    "gomod": SemgrepGoLibrarySchema,
+    "npm": SemgrepNpmLibrarySchema,
 }
 
 
 def parse_and_validate_semgrep_ecosystems(ecosystems: str) -> List[str]:
     validated_ecosystems: List[str] = []
-    for ecosystem in ecosystems.split(','):
+    for ecosystem in ecosystems.split(","):
         ecosystem = ecosystem.strip().lower()
 
         if ecosystem in ECOSYSTEM_TO_SCHEMA:
             validated_ecosystems.append(ecosystem)
         else:
-            valid_ecosystems: str = ','.join(ECOSYSTEM_TO_SCHEMA.keys())
+            valid_ecosystems: str = ",".join(ECOSYSTEM_TO_SCHEMA.keys())
             raise ValueError(
                 f'Error parsing `semgrep-dependency-ecosystems`. You specified "{ecosystems}". '
                 f'Please check that your input is formatted as comma-separated values, e.g. "gomod,npm". '
-                f'Full list of supported ecosystems: {valid_ecosystems}.',
+                f"Full list of supported ecosystems: {valid_ecosystems}.",
             )
     return validated_ecosystems
 
 
 @timeit
-def get_dependencies(semgrep_app_token: str, deployment_id: str, ecosystem: str) -> List[Dict[str, Any]]:
+def get_dependencies(
+    semgrep_app_token: str,
+    deployment_id: str,
+    ecosystem: str,
+) -> List[Dict[str, Any]]:
     """
     Gets all dependencies for the given ecosystem within the given Semgrep deployment ID.
     param: semgrep_app_token: The Semgrep App token to use for authentication.
@@ -73,14 +77,23 @@ def get_dependencies(semgrep_app_token: str, deployment_id: str, ecosystem: str)
         },
     }
 
-    logger.info(f"Retrieving Semgrep {ecosystem} dependencies for deployment '{deployment_id}'.")
+    logger.info(
+        f"Retrieving Semgrep {ecosystem} dependencies for deployment '{deployment_id}'.",
+    )
     while has_more:
         try:
-            response = requests.post(deps_url, json=request_data, headers=headers, timeout=_TIMEOUT)
+            response = requests.post(
+                deps_url,
+                json=request_data,
+                headers=headers,
+                timeout=_TIMEOUT,
+            )
             response.raise_for_status()
             data = response.json()
         except (ReadTimeout, HTTPError):
-            logger.warning(f"Failed to retrieve Semgrep {ecosystem} dependencies for page {page}. Retrying...")
+            logger.warning(
+                f"Failed to retrieve Semgrep {ecosystem} dependencies for page {page}. Retrying...",
+            )
             retries += 1
             if retries >= _MAX_RETRIES:
                 raise
@@ -93,7 +106,9 @@ def get_dependencies(semgrep_app_token: str, deployment_id: str, ecosystem: str)
         page += 1
         request_data["cursor"] = data.get("cursor")
 
-    logger.info(f"Retrieved {len(all_deps)} Semgrep {ecosystem} dependencies in {page} pages.")
+    logger.info(
+        f"Retrieved {len(all_deps)} Semgrep {ecosystem} dependencies in {page} pages.",
+    )
     return all_deps
 
 
@@ -142,19 +157,20 @@ def transform_dependencies(raw_deps: List[Dict[str, Any]]) -> List[Dict[str, Any
         # If Semgrep eventually supports version specifiers, update this line accordingly.
         specifier = f"=={version}"
 
-        deps.append({
-            # existing dependency properties:
-            "id": id,
-            "name": name,
-            "specifier": specifier,
-            "version": version,
-            "repo_url": repo_url,
-
-            # Semgrep-specific properties:
-            "ecosystem": raw_dep["ecosystem"],
-            "transitivity": raw_dep["transitivity"].lower(),
-            "url": raw_dep["definedAt"]["url"],
-        })
+        deps.append(
+            {
+                # existing dependency properties:
+                "id": id,
+                "name": name,
+                "specifier": specifier,
+                "version": version,
+                "repo_url": repo_url,
+                # Semgrep-specific properties:
+                "ecosystem": raw_dep["ecosystem"],
+                "transitivity": raw_dep["transitivity"].lower(),
+                "url": raw_dep["definedAt"]["url"],
+            },
+        )
 
     return deps
 
@@ -167,7 +183,9 @@ def load_dependencies(
     deployment_id: str,
     update_tag: int,
 ) -> None:
-    logger.info(f"Loading {len(dependencies)} {dependency_schema().label} objects into the graph.")
+    logger.info(
+        f"Loading {len(dependencies)} {dependency_schema().label} objects into the graph.",
+    )
     load(
         neo4j_session,
         dependency_schema(),
@@ -183,8 +201,12 @@ def cleanup(
     dependency_schema: Callable,
     common_job_parameters: Dict[str, Any],
 ) -> None:
-    logger.info(f"Running Semgrep Dependencies cleanup job for {dependency_schema().label}.")
-    GraphJob.from_node_schema(dependency_schema(), common_job_parameters).run(neo4j_session)
+    logger.info(
+        f"Running Semgrep Dependencies cleanup job for {dependency_schema().label}.",
+    )
+    GraphJob.from_node_schema(dependency_schema(), common_job_parameters).run(
+        neo4j_session,
+    )
 
 
 @timeit
@@ -225,9 +247,9 @@ def sync_dependencies(
 
     merge_module_sync_metadata(
         neo4j_session=neo4j_session,
-        group_type='Semgrep',
+        group_type="Semgrep",
         group_id=deployment_id,
-        synced_type='SemgrepDependency',
+        synced_type="SemgrepDependency",
         update_tag=update_tag,
         stat_handler=stat_handler,
     )

cartography/intel/semgrep/deployment.py

@@ -40,7 +40,9 @@ def get_deployment(semgrep_app_token: str) -> Dict[str, Any]:
 
 @timeit
 def load_semgrep_deployment(
-    neo4j_session: neo4j.Session, deployment: Dict[str, Any], update_tag: int,
+    neo4j_session: neo4j.Session,
+    deployment: Dict[str, Any],
+    update_tag: int,
 ) -> None:
     logger.info(f"Loading SemgrepDeployment {deployment} into the graph.")
     load(

cartography/intel/semgrep/findings.py

@@ -54,11 +54,18 @@ def get_sca_vulns(semgrep_app_token: str, deployment_slug: str) -> List[Dict[str
     while has_more:
 
         try:
-            response = requests.get(sca_url, params=request_data, headers=headers, timeout=_TIMEOUT)
+            response = requests.get(
+                sca_url,
+                params=request_data,
+                headers=headers,
+                timeout=_TIMEOUT,
+            )
             response.raise_for_status()
             data = response.json()
         except (ReadTimeout, HTTPError):
-            logger.warning(f"Failed to retrieve Semgrep SCA vulns for page {page}. Retrying...")
+            logger.warning(
+                f"Failed to retrieve Semgrep SCA vulns for page {page}. Retrying...",
+            )
             retries += 1
             if retries >= _MAX_RETRIES:
                 raise
@@ -104,14 +111,16 @@ def _determine_exposure(vuln: Dict[str, Any]) -> str | None:
 
 
 def _build_vuln_url(vuln: str) -> str | None:
-    if 'CVE' in vuln:
+    if "CVE" in vuln:
         return f"https://nvd.nist.gov/vuln/detail/{vuln}"
-    if 'GHSA' in vuln:
+    if "GHSA" in vuln:
         return f"https://github.com/advisories/{vuln}"
     return None
 
 
-def transform_sca_vulns(raw_vulns: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], List[Dict[str, str]]]:
+def transform_sca_vulns(
+    raw_vulns: List[Dict[str, Any]],
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, str]]]:
     """
     Transforms the raw SCA vulns response from Semgrep API into a list of dicts
     that can be used to create the SemgrepSCAFinding nodes.
@@ -124,7 +133,7 @@ def transform_sca_vulns(raw_vulns: List[Dict[str, Any]]) -> Tuple[List[Dict[str,
         repository_name = vuln["repository"]["name"]
         rule_id = vuln["rule"]["name"]
         vulnerability_class = _get_vuln_class(vuln)
-        package = vuln['found_dependency']['package']
+        package = vuln["found_dependency"]["package"]
         sca_vuln["id"] = vuln["id"]
         sca_vuln["repositoryName"] = repository_name
         sca_vuln["branch"] = vuln["ref"]
@@ -133,9 +142,15 @@ def transform_sca_vulns(raw_vulns: List[Dict[str, Any]]) -> Tuple[List[Dict[str,
         sca_vuln["description"] = vuln["rule"]["message"]
         sca_vuln["ecosystem"] = vuln["found_dependency"]["ecosystem"]
         sca_vuln["severity"] = vuln["severity"].upper()
-        sca_vuln["reachability"] = vuln["reachability"].upper()  # Check done to determine rechabilitity
-        sca_vuln["reachableIf"] = vuln["reachable_condition"].upper() if vuln["reachable_condition"] else None
-        sca_vuln["exposureType"] = _determine_exposure(vuln)  # Determintes if reachable or unreachable
+        sca_vuln["reachability"] = vuln[
+            "reachability"
+        ].upper()  # Check done to determine rechabilitity
+        sca_vuln["reachableIf"] = (
+            vuln["reachable_condition"].upper() if vuln["reachable_condition"] else None
+        )
+        sca_vuln["exposureType"] = _determine_exposure(
+            vuln,
+        )  # Determintes if reachable or unreachable
         dependency = f"{package}|{vuln['found_dependency']['version']}"
         sca_vuln["matchedDependency"] = dependency
         dep_url = vuln["found_dependency"]["lockfile_line_url"]
@@ -145,14 +160,16 @@ def transform_sca_vulns(raw_vulns: List[Dict[str, Any]]) -> Tuple[List[Dict[str,
             sca_vuln["dependencyFileLocation_url"] = dep_url
         else:
             if sca_vuln.get("location"):
-                sca_vuln["dependencyFileLocation_path"] = sca_vuln["location"]["file_path"]
+                sca_vuln["dependencyFileLocation_path"] = sca_vuln["location"][
+                    "file_path"
+                ]
         sca_vuln["transitivity"] = vuln["found_dependency"]["transitivity"].upper()
         if vuln.get("vulnerability_identifier"):
             vuln_id = vuln["vulnerability_identifier"].upper()
             sca_vuln["cveId"] = vuln_id
             sca_vuln["ref_urls"] = [_build_vuln_url(vuln_id)]
-        if vuln.get('fix_recommendations') and len(vuln['fix_recommendations']) > 0:
-            fix = vuln['fix_recommendations'][0]
+        if vuln.get("fix_recommendations") and len(vuln["fix_recommendations"]) > 0:
+            fix = vuln["fix_recommendations"][0]
             dep_fix = f"{fix['package']}|{fix['version']}"
             sca_vuln["closestSafeDependency"] = dep_fix
         sca_vuln["openedAt"] = vuln["created_at"]
@@ -213,16 +230,19 @@ def load_semgrep_sca_usages(
 
 @timeit
 def cleanup(
-    neo4j_session: neo4j.Session, common_job_parameters: Dict[str, Any],
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict[str, Any],
 ) -> None:
     logger.info("Running Semgrep SCA findings cleanup job.")
     findings_cleanup_job = GraphJob.from_node_schema(
-        SemgrepSCAFindingSchema(), common_job_parameters,
+        SemgrepSCAFindingSchema(),
+        common_job_parameters,
     )
     findings_cleanup_job.run(neo4j_session)
     logger.info("Running Semgrep SCA Locations cleanup job.")
     locations_cleanup_job = GraphJob.from_node_schema(
-        SemgrepSCALocationSchema(), common_job_parameters,
+        SemgrepSCALocationSchema(),
+        common_job_parameters,
     )
     locations_cleanup_job.run(neo4j_session)
 
@@ -249,14 +269,18 @@ def sync_findings(
     vulns, usages = transform_sca_vulns(raw_vulns)
     load_semgrep_sca_vulns(neo4j_session, vulns, deployment_id, update_tag)
     load_semgrep_sca_usages(neo4j_session, usages, deployment_id, update_tag)
-    run_scoped_analysis_job('semgrep_sca_risk_analysis.json', neo4j_session, common_job_parameters)
+    run_scoped_analysis_job(
+        "semgrep_sca_risk_analysis.json",
+        neo4j_session,
+        common_job_parameters,
+    )
 
     cleanup(neo4j_session, common_job_parameters)
     merge_module_sync_metadata(
         neo4j_session=neo4j_session,
-        group_type='Semgrep',
+        group_type="Semgrep",
         group_id=deployment_id,
-        synced_type='SCA',
+        synced_type="SCA",
         update_tag=update_tag,
         stat_handler=stat_handler,
     )

cartography/intel/snipeit/__init__.py

@@ -14,7 +14,11 @@ stat_handler = get_stats_client(__name__)
 
 @timeit
 def start_snipeit_ingestion(neo4j_session: neo4j.Session, config: Config) -> None:
-    if config.snipeit_base_uri is None or config.snipeit_token is None or config.snipeit_tenant_id is None:
+    if (
+        config.snipeit_base_uri is None
+        or config.snipeit_token is None
+        or config.snipeit_tenant_id is None
+    ):
         logger.warning(
             "Required parameter(s) missing. Skipping sync.",
         )
@@ -26,5 +30,15 @@ def start_snipeit_ingestion(neo4j_session: neo4j.Session, config: Config) -> Non
     }
 
     # Ingest SnipeIT users and assets
-    user.sync(neo4j_session, common_job_parameters, config.snipeit_base_uri, config.snipeit_token)
-    asset.sync(neo4j_session, common_job_parameters, config.snipeit_base_uri, config.snipeit_token)
+    user.sync(
+        neo4j_session,
+        common_job_parameters,
+        config.snipeit_base_uri,
+        config.snipeit_token,
+    )
+    asset.sync(
+        neo4j_session,
+        common_job_parameters,
+        config.snipeit_base_uri,
+        config.snipeit_token,
+    )