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

cartography/models/snipeit/user.py

@@ -15,35 +15,42 @@ class SnipeitUserNodeProperties(CartographyNodeProperties):
     """
     Ref: https://snipe-it.readme.io/reference/users
     """
+
     # Common properties
-    id: PropertyRef = PropertyRef('id')
-    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+    id: PropertyRef = PropertyRef("id")
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
 
     # SnipeIT specific properties
-    company: PropertyRef = PropertyRef('company_id.name', extra_index=True)
-    email: PropertyRef = PropertyRef('email', extra_index=True)
-    username: PropertyRef = PropertyRef('username')
+    company: PropertyRef = PropertyRef("company_id.name", extra_index=True)
+    email: PropertyRef = PropertyRef("email", extra_index=True)
+    username: PropertyRef = PropertyRef("username")
 
 
 @dataclass(frozen=True)
 class SnipeitTenantToSnipeitUserRelProperties(CartographyRelProperties):
-    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef("lastupdated", set_in_kwargs=True)
 
 
 @dataclass(frozen=True)
 # (:SnipeitTenant)-[:HAS_USER]->(:SnipeitUser)
 class SnipeitTenantToSnipeitUserRel(CartographyRelSchema):
-    target_node_label: str = 'SnipeitTenant'
+    target_node_label: str = "SnipeitTenant"
     target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
-        {'id': PropertyRef('TENANT_ID', set_in_kwargs=True)},
+        {"id": PropertyRef("TENANT_ID", set_in_kwargs=True)},
     )
     direction: LinkDirection = LinkDirection.INWARD
     rel_label: str = "HAS_USER"
-    properties: SnipeitTenantToSnipeitUserRelProperties = SnipeitTenantToSnipeitUserRelProperties()
+    properties: SnipeitTenantToSnipeitUserRelProperties = (
+        SnipeitTenantToSnipeitUserRelProperties()
+    )
 
 
 @dataclass(frozen=True)
 class SnipeitUserSchema(CartographyNodeSchema):
-    label: str = 'SnipeitUser'  # The label of the node
-    properties: SnipeitUserNodeProperties = SnipeitUserNodeProperties()  # An object representing all properties
-    sub_resource_relationship: SnipeitTenantToSnipeitUserRel = SnipeitTenantToSnipeitUserRel()
+    label: str = "SnipeitUser"  # The label of the node
+    properties: SnipeitUserNodeProperties = (
+        SnipeitUserNodeProperties()
+    )  # An object representing all properties
+    sub_resource_relationship: SnipeitTenantToSnipeitUserRel = (
+        SnipeitTenantToSnipeitUserRel()
+    )

cartography/stats.py

@@ -17,11 +17,11 @@ class ScopedStatsClient:
 
     _client: StatsClient = None
 
-    def __init__(self, prefix: Optional[str], root: 'ScopedStatsClient'):
+    def __init__(self, prefix: Optional[str], root: "ScopedStatsClient"):
         self._scope_prefix = prefix
         self._root = root
 
-    def get_stats_client(self, scope: str) -> 'ScopedStatsClient':
+    def get_stats_client(self, scope: str) -> "ScopedStatsClient":
         """
         This method returns a new proxy to the same client
         which will prefix all calls to underlying methods with the scoped prefix
@@ -35,7 +35,7 @@ class ScopedStatsClient:
         return scoped_stats_client
 
     @staticmethod
-    def get_root_client() -> 'ScopedStatsClient':
+    def get_root_client() -> "ScopedStatsClient":
         client = ScopedStatsClient(prefix=None, root=None)  # type: ignore
         client._root = client
         return client

cartography/sync.py

@@ -1,7 +1,9 @@
 import argparse
 import logging
+import re
 import time
 from collections import OrderedDict
+from pkgutil import iter_modules
 from typing import Callable
 from typing import List
 from typing import Tuple
@@ -39,28 +41,30 @@ from cartography.util import STATUS_SUCCESS
 logger = logging.getLogger(__name__)
 
 
-TOP_LEVEL_MODULES = OrderedDict({  # preserve order so that the default sync always runs `analysis` at the very end
-    'create-indexes': cartography.intel.create_indexes.run,
-    'aws': cartography.intel.aws.start_aws_ingestion,
-    'azure': cartography.intel.azure.start_azure_ingestion,
-    'entra': cartography.intel.entra.start_entra_ingestion,
-    'crowdstrike': cartography.intel.crowdstrike.start_crowdstrike_ingestion,
-    'gcp': cartography.intel.gcp.start_gcp_ingestion,
-    'gsuite': cartography.intel.gsuite.start_gsuite_ingestion,
-    'cve': cartography.intel.cve.start_cve_ingestion,
-    'oci': cartography.intel.oci.start_oci_ingestion,
-    'okta': cartography.intel.okta.start_okta_ingestion,
-    'github': cartography.intel.github.start_github_ingestion,
-    'digitalocean': cartography.intel.digitalocean.start_digitalocean_ingestion,
-    'kandji': cartography.intel.kandji.start_kandji_ingestion,
-    'kubernetes': cartography.intel.kubernetes.start_k8s_ingestion,
-    'lastpass': cartography.intel.lastpass.start_lastpass_ingestion,
-    'bigfix': cartography.intel.bigfix.start_bigfix_ingestion,
-    'duo': cartography.intel.duo.start_duo_ingestion,
-    'semgrep': cartography.intel.semgrep.start_semgrep_ingestion,
-    'snipeit': cartography.intel.snipeit.start_snipeit_ingestion,
-    'analysis': cartography.intel.analysis.run,
-})
+TOP_LEVEL_MODULES = OrderedDict(
+    {  # preserve order so that the default sync always runs `analysis` at the very end
+        "create-indexes": cartography.intel.create_indexes.run,
+        "aws": cartography.intel.aws.start_aws_ingestion,
+        "azure": cartography.intel.azure.start_azure_ingestion,
+        "entra": cartography.intel.entra.start_entra_ingestion,
+        "crowdstrike": cartography.intel.crowdstrike.start_crowdstrike_ingestion,
+        "gcp": cartography.intel.gcp.start_gcp_ingestion,
+        "gsuite": cartography.intel.gsuite.start_gsuite_ingestion,
+        "cve": cartography.intel.cve.start_cve_ingestion,
+        "oci": cartography.intel.oci.start_oci_ingestion,
+        "okta": cartography.intel.okta.start_okta_ingestion,
+        "github": cartography.intel.github.start_github_ingestion,
+        "digitalocean": cartography.intel.digitalocean.start_digitalocean_ingestion,
+        "kandji": cartography.intel.kandji.start_kandji_ingestion,
+        "kubernetes": cartography.intel.kubernetes.start_k8s_ingestion,
+        "lastpass": cartography.intel.lastpass.start_lastpass_ingestion,
+        "bigfix": cartography.intel.bigfix.start_bigfix_ingestion,
+        "duo": cartography.intel.duo.start_duo_ingestion,
+        "semgrep": cartography.intel.semgrep.start_semgrep_ingestion,
+        "snipeit": cartography.intel.snipeit.start_snipeit_ingestion,
+        "analysis": cartography.intel.analysis.run,
+    }
+)
 
 
 class Sync:
@@ -98,7 +102,11 @@ class Sync:
         for name, func in stages:
             self.add_stage(name, func)
 
-    def run(self, neo4j_driver: neo4j.Driver, config: Union[Config, argparse.Namespace]) -> int:
+    def run(
+        self,
+        neo4j_driver: neo4j.Driver,
+        config: Union[Config, argparse.Namespace],
+    ) -> int:
         """
         Execute all stages in the sync task in sequence.
 
@@ -117,12 +125,77 @@ class Sync:
                     logger.warning("Sync interrupted during stage '%s'.", stage_name)
                     raise
                 except Exception:
-                    logger.exception("Unhandled exception during sync stage '%s'", stage_name)
+                    logger.exception(
+                        "Unhandled exception during sync stage '%s'",
+                        stage_name,
+                    )
                     raise  # TODO this should be configurable
                 logger.info("Finishing sync stage '%s'", stage_name)
         logger.info("Finishing sync with update tag '%d'", config.update_tag)
         return STATUS_SUCCESS
 
+    @classmethod
+    def list_intel_modules(cls) -> OrderedDict:
+        """
+        List all available intel modules.
+
+        This method will load all modules in the cartography.intel package and return a dictionary of their names and
+        their callable functions. The keys of the dictionary are the module names, and the values are the callable
+        functions (with `start_{module}_ingestion` pattern) that should be executed during the sync process.
+        analysis and create_indexes are loaded separately to ensure they are always available and run first
+        (for create-index) and last (for analysis).
+
+        :rtype: OrderedDict
+        :return: A dictionary of available intel modules.
+        """
+        available_modules = OrderedDict({})
+        available_modules["create-indexes"] = cartography.intel.create_indexes.run
+        callable_regex = re.compile(r"^start_(.+)_ingestion$")
+        # Load built-in modules
+        for intel_module_info in iter_modules(cartography.intel.__path__):
+            if intel_module_info.name in ("analysis", "create_indexes"):
+                continue
+            try:
+                logger.debug("Loading module: %s", intel_module_info.name)
+                intel_module = __import__(
+                    f"cartography.intel.{intel_module_info.name}",
+                    fromlist=[""],
+                )
+            except ImportError as e:
+                logger.error(
+                    "Failed to import module '%s'. Error: %s",
+                    intel_module_info.name,
+                    e,
+                )
+                continue
+            logger.debug("Loading module: %s", intel_module_info.name)
+            intel_module = __import__(
+                f"cartography.intel.{intel_module_info.name}",
+                fromlist=[""],
+            )
+            for k, v in intel_module.__dict__.items():
+                if not callable(v):
+                    continue
+                match_callable_name = callable_regex.match(k)
+                if not match_callable_name:
+                    continue
+                callable_module_name = (
+                    match_callable_name.group(1) if match_callable_name else None
+                )
+                if callable_module_name != intel_module_info.name:
+                    logger.debug(
+                        "Module name '%s' does not match intel module name '%s'.",
+                        callable_module_name,
+                        intel_module_info.name,
+                    )
+                available_modules[intel_module_info.name] = v
+        available_modules["analysis"] = cartography.intel.analysis.run
+        return available_modules
+
+
+# Used to avoid repeatedly calling Sync.list_intel_modules()
+TOP_LEVEL_MODULES = Sync.list_intel_modules()
+
 
 def run_with_config(sync: Sync, config: Union[Config, argparse.Namespace]) -> int:
     """
@@ -201,9 +274,12 @@ def build_default_sync() -> Sync:
     :return: The default cartography sync object.
     """
     sync = Sync()
-    sync.add_stages([
-        (stage_name, stage_func) for stage_name, stage_func in TOP_LEVEL_MODULES.items()
-    ])
+    sync.add_stages(
+        [
+            (stage_name, stage_func)
+            for stage_name, stage_func in TOP_LEVEL_MODULES.items()
+        ],
+    )
     return sync
 
 
@@ -214,18 +290,18 @@ def parse_and_validate_selected_modules(selected_modules: str) -> List[str]:
     :return: A validated list of module names that we will run
     """
     validated_modules: List[str] = []
-    for module in selected_modules.split(','):
+    for module in selected_modules.split(","):
         module = module.strip()
 
         if module in TOP_LEVEL_MODULES.keys():
             validated_modules.append(module)
         else:
-            valid_modules = ', '.join(TOP_LEVEL_MODULES.keys())
+            valid_modules = ", ".join(TOP_LEVEL_MODULES.keys())
             raise ValueError(
                 f'Error parsing `selected_modules`. You specified "{selected_modules}". '
-                f'Please check that your string is formatted properly. '
+                f"Please check that your string is formatted properly. "
                 f'Example valid input looks like "aws,gcp,analysis" or "azure, oci, crowdstrike". '
-                f'Our full list of valid values is: {valid_modules}.',
+                f"Our full list of valid values is: {valid_modules}.",
             )
     return validated_modules
 

cartography/util.py

@@ -30,7 +30,6 @@ from cartography.graph.statement import get_job_shortname
 from cartography.stats import get_stats_client
 from cartography.stats import ScopedStatsClient
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -44,7 +43,7 @@ def run_analysis_job(
     filename: str,
     neo4j_session: neo4j.Session,
     common_job_parameters: Dict,
-    package: str = 'cartography.data.jobs.analysis',
+    package: str = "cartography.data.jobs.analysis",
 ) -> None:
     """
     Enriches existing graph data with analysis jobs. This is designed for use with the sync stage
@@ -66,11 +65,11 @@ def run_analysis_job(
 
 
 def run_analysis_and_ensure_deps(
-        analysis_job_name: str,
-        resource_dependencies: Set[str],
-        requested_syncs: Set[str],
-        common_job_parameters: Dict[str, Any],
-        neo4j_session: neo4j.Session,
+    analysis_job_name: str,
+    resource_dependencies: Set[str],
+    requested_syncs: Set[str],
+    common_job_parameters: Dict[str, Any],
+    neo4j_session: neo4j.Session,
 ) -> None:
     """
     Runs analysis job only if the given set of resource dependencies was included in the requested_syncs.
@@ -100,7 +99,7 @@ def run_scoped_analysis_job(
     filename: str,
     neo4j_session: neo4j.Session,
     common_job_parameters: Dict,
-    package: str = 'cartography.data.jobs.scoped_analysis',
+    package: str = "cartography.data.jobs.scoped_analysis",
 ) -> None:
     """
     Enriches existing graph data scoped to a given sub resource - e.g. the current AWS account.
@@ -116,8 +115,10 @@ def run_scoped_analysis_job(
 
 
 def run_cleanup_job(
-    filename: str, neo4j_session: neo4j.Session, common_job_parameters: Dict,
-    package: str = 'cartography.data.jobs.cleanup',
+    filename: str,
+    neo4j_session: neo4j.Session,
+    common_job_parameters: Dict,
+    package: str = "cartography.data.jobs.cleanup",
 ) -> None:
     GraphJob.run_from_json(
         neo4j_session,
@@ -138,7 +139,7 @@ def merge_module_sync_metadata(
     update_tag: int,
     stat_handler: ScopedStatsClient,
 ) -> None:
-    '''
+    """
     This creates `ModuleSyncMetadata` nodes when called from each of the individual modules or sub-modules.
     The 'types' used here should be actual node labels. For example, if we did sync a particular AWSAccount's S3Buckets,
     the `grouptype` is 'AWSAccount', the `groupid` is the particular account's `id`, and the `syncedtype` is 'S3Bucket'.
@@ -148,8 +149,9 @@ def merge_module_sync_metadata(
     :param group_id: The parent module's id
     :param synced_type: The sub-module's type
     :param update_tag: Timestamp used to determine data freshness
-    '''
-    template = Template("""
+    """
+    template = Template(
+        """
         MERGE (n:ModuleSyncMetadata{id:'${group_type}_${group_id}_${synced_type}'})
         ON CREATE SET
             n:SyncMetadata, n.firstseen=timestamp()
@@ -157,20 +159,25 @@ def merge_module_sync_metadata(
             n.grouptype='${group_type}',
             n.groupid='${group_id}',
             n.lastupdated=$UPDATE_TAG
-    """)
+    """,
+    )
     neo4j_session.run(
-        template.safe_substitute(group_type=group_type, group_id=group_id, synced_type=synced_type),
+        template.safe_substitute(
+            group_type=group_type,
+            group_id=group_id,
+            synced_type=synced_type,
+        ),
         UPDATE_TAG=update_tag,
     )
-    stat_handler.incr(f'{group_type}_{group_id}_{synced_type}_lastupdated', update_tag)
+    stat_handler.incr(f"{group_type}_{group_id}_{synced_type}_lastupdated", update_tag)
 
 
 def load_resource_binary(package: str, resource_name: str) -> BinaryIO:
     return open_binary(package, resource_name)
 
 
-R = TypeVar('R')
-F = TypeVar('F', bound=Callable[..., Any])
+R = TypeVar("R")
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 def timeit(method: F) -> F:
@@ -179,6 +186,7 @@ def timeit(method: F) -> F:
     This is only active if config.statsd_enabled is True.
     :param method: The function to measure execution
     """
+
     # Allow access via `inspect` to the wrapped function. This is used in integration tests to standardize param names.
     @wraps(method)
     def timed(*args, **kwargs):  # type: ignore
@@ -202,40 +210,44 @@ def aws_paginate(
     object_name: str,
     **kwargs: Any,
 ) -> List[Dict]:
-    '''
+    """
     Helper method for boilerplate boto3 pagination
     The **kwargs will be forwarded to the paginator
-    '''
+    """
     paginator = client.get_paginator(method_name)
     items = []
     i = 0
     for i, page in enumerate(paginator.paginate(**kwargs), start=1):
         if i % 100 == 0:
-            logger.info(f'fetching page number {i}')
+            logger.info(f"fetching page number {i}")
         if object_name in page:
             items.extend(page[object_name])
         else:
             logger.warning(
-                f'''aws_paginate: Key "{object_name}" is not present, check if this is a typo.
-If not, then the AWS datatype somehow does not have this key.''',
+                f"""aws_paginate: Key "{object_name}" is not present, check if this is a typo.
+If not, then the AWS datatype somehow does not have this key.""",
             )
     return items
 
 
-AWSGetFunc = TypeVar('AWSGetFunc', bound=Callable[..., Iterable])
+AWSGetFunc = TypeVar("AWSGetFunc", bound=Callable[..., Iterable])
 
 # fix for AWS TooManyRequestsException
-# https://github.com/lyft/cartography/issues/297
-# https://github.com/lyft/cartography/issues/243
-# https://github.com/lyft/cartography/issues/65
-# https://github.com/lyft/cartography/issues/25
+# https://github.com/cartography-cncf/cartography/issues/297
+# https://github.com/cartography-cncf/cartography/issues/243
+# https://github.com/cartography-cncf/cartography/issues/65
+# https://github.com/cartography-cncf/cartography/issues/25
 
 
 def backoff_handler(details: Dict) -> None:
     """
     Handler that will be executed on exception by backoff mechanism
     """
-    logger.warning("Backing off {wait:0.1f} seconds after {tries} tries. Calling function {target}".format(**details))
+    logger.warning(
+        "Backing off {wait:0.1f} seconds after {tries} tries. Calling function {target}".format(
+            **details,
+        ),
+    )
 
 
 # TODO Move this to cartography.intel.aws.util.common
@@ -250,21 +262,21 @@ def aws_handle_regions(func: AWSGetFunc) -> AWSGetFunc:
     This should be used on `get_` functions that normally return a list of items.
     """
     ERROR_CODES = [
-        'AccessDenied',
-        'AccessDeniedException',
-        'AuthFailure',
-        'InvalidClientTokenId',
-        'UnauthorizedOperation',
-        'UnrecognizedClientException',
-        'InternalServerErrorException',
+        "AccessDenied",
+        "AccessDeniedException",
+        "AuthFailure",
+        "InvalidClientTokenId",
+        "UnauthorizedOperation",
+        "UnrecognizedClientException",
+        "InternalServerErrorException",
     ]
 
     @wraps(func)
     # fix for AWS TooManyRequestsException
-    # https://github.com/lyft/cartography/issues/297
-    # https://github.com/lyft/cartography/issues/243
-    # https://github.com/lyft/cartography/issues/65
-    # https://github.com/lyft/cartography/issues/25
+    # https://github.com/cartography-cncf/cartography/issues/297
+    # https://github.com/cartography-cncf/cartography/issues/243
+    # https://github.com/cartography-cncf/cartography/issues/65
+    # https://github.com/cartography-cncf/cartography/issues/25
     @backoff.on_exception(
         backoff.expo,
         botocore.exceptions.ClientError,
@@ -277,23 +289,29 @@ def aws_handle_regions(func: AWSGetFunc) -> AWSGetFunc:
         except botocore.exceptions.ClientError as e:
             # The account is not authorized to use this service in this region
             # so we can continue without raising an exception
-            if e.response['Error']['Code'] in ERROR_CODES:
-                logger.warning("{} in this region. Skipping...".format(e.response['Error']['Message']))
+            if e.response["Error"]["Code"] in ERROR_CODES:
+                logger.warning(
+                    "{} in this region. Skipping...".format(
+                        e.response["Error"]["Message"],
+                    ),
+                )
                 return []
             else:
                 raise
+
     return cast(AWSGetFunc, inner_function)
 
 
 def retries_with_backoff(
-        func: Callable,
-        exception_type: Type[Exception],
-        max_tries: int,
-        on_backoff: Callable,
+    func: Callable,
+    exception_type: Type[Exception],
+    max_tries: int,
+    on_backoff: Callable,
 ) -> Callable:
     """
     Adds retry with backoff to the given function.  (Could expand the possible input parameters as needed.)
     """
+
     @wraps(func)
     @backoff.on_exception(
         backoff.expo,
@@ -303,6 +321,7 @@ def retries_with_backoff(
     )
     def inner_function(*args, **kwargs):  # type: ignore
         return func(*args, **kwargs)
+
     return cast(Callable, inner_function)
 
 
@@ -331,32 +350,29 @@ def dict_date_to_epoch(obj: Dict, key: str) -> Optional[int]:
 
 
 def camel_to_snake(name: str) -> str:
-    return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()
 
 
 def batch(items: Iterable, size: int = DEFAULT_BATCH_SIZE) -> List[List]:
-    '''
+    """
     Takes an Iterable of items and returns a list of lists of the same items,
      batched into chunks of the provided `size`.
 
     Use:
     x = [1,2,3,4,5,6,7,8]
     batch(x, size=3) -> [[1, 2, 3], [4, 5, 6], [7, 8]]
-    '''
+    """
     items = list(items)
-    return [
-        items[i: i + size]
-        for i in range(0, len(items), size)
-    ]
+    return [items[i : i + size] for i in range(0, len(items), size)]
 
 
 def is_throttling_exception(exc: Exception) -> bool:
-    '''
+    """
     Returns True if the exception is caused by a client libraries throttling mechanism
-    '''
+    """
     # https://boto3.amazonaws.com/v1/documentation/api/1.19.9/guide/error-handling.html
     if isinstance(exc, botocore.exceptions.ClientError):
-        if exc.response['Error']['Code'] in ['LimitExceededException', 'Throttling']:
+        if exc.response["Error"]["Code"] in ["LimitExceededException", "Throttling"]:
             return True
     # add other exceptions here, if needed, like:
     # https://cloud.google.com/python/docs/reference/storage/1.39.0/retry_timeout#configuring-retries
@@ -366,7 +382,7 @@ def is_throttling_exception(exc: Exception) -> bool:
 
 
 def to_asynchronous(func: Callable[..., R], *args: Any, **kwargs: Any) -> Awaitable[R]:
-    '''
+    """
     Returns a Future that will run a function and its arguments in the default threadpool.
     Helper until we start using python 3.9's asyncio.to_thread
 
@@ -396,8 +412,12 @@ def to_asynchronous(func: Callable[..., R], *args: Any, **kwargs: Any) -> Awaita
     NOTE: to use this in a Jupyter notebook, you need to do:
     # import nest_asyncio
     # nest_asyncio.apply()
-    '''
-    CartographyThrottlingException = type('CartographyThrottlingException', (Exception,), {})
+    """
+    CartographyThrottlingException = type(
+        "CartographyThrottlingException",
+        (Exception,),
+        {},
+    )
 
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> R:
@@ -409,13 +429,15 @@ def to_asynchronous(func: Callable[..., R], *args: Any, **kwargs: Any) -> Awaita
             raise
 
     # don't use @backoff as decorator, to preserve typing
-    wrapped = backoff.on_exception(backoff.expo, CartographyThrottlingException)(wrapper)
+    wrapped = backoff.on_exception(backoff.expo, CartographyThrottlingException)(
+        wrapper,
+    )
     call = partial(wrapped, *args, **kwargs)
     return asyncio.get_event_loop().run_in_executor(None, call)
 
 
 def to_synchronous(*awaitables: Awaitable[Any]) -> List[Any]:
-    '''
+    """
     Synchronously waits for the Awaitable(s) to complete and returns their result(s).
     See https://docs.python.org/3.8/library/asyncio-task.html#asyncio-awaitables
 
@@ -437,5 +459,5 @@ def to_synchronous(*awaitables: Awaitable[Any]) -> List[Any]:
     future_2 = another_async_func(2)
 
     results = to_synchronous(future_1, future_2)
-    '''
+    """
     return asyncio.get_event_loop().run_until_complete(asyncio.gather(*awaitables))

{cartography-0.102.0rc1.dist-info → cartography-0.103.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cartography
-Version: 0.102.0rc1
+Version: 0.103.0rc1
 Summary: Explore assets and their relationships across your technical infrastructure.
 Maintainer: Cartography Contributors
 License: apache2
@@ -54,17 +54,6 @@ Requires-Dist: crowdstrike-falconpy>=0.5.1
 Requires-Dist: python-dateutil
 Requires-Dist: xmltodict
 Requires-Dist: duo-client
-Provides-Extra: dev
-Requires-Dist: backoff>=2.1.2; extra == "dev"
-Requires-Dist: moto; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: pytest>=6.2.4; extra == "dev"
-Requires-Dist: pytest-mock; extra == "dev"
-Requires-Dist: pytest-cov==6.1.1; extra == "dev"
-Requires-Dist: pytest-rerunfailures; extra == "dev"
-Requires-Dist: pytest-asyncio; extra == "dev"
-Requires-Dist: types-PyYAML; extra == "dev"
-Requires-Dist: types-requests<2.32.0.20250329; extra == "dev"
 Dynamic: license-file
 
 ![Cartography](docs/root/images/logo-horizontal.png)
@@ -91,7 +80,7 @@ You can learn more about the story behind Cartography in our [presentation at BS
 
 ## Supported platforms
 
-- [Amazon Web Services](https://cartography-cncf.github.io/cartography/modules/aws/index.html) - API Gateway, Config, EC2, ECS, ECR, Elasticsearch, Elastic Kubernetes Service (EKS), DynamoDB, IAM, Inspector, KMS, Lambda, RDS, Redshift, Route53, S3, Secrets Manager, Security Hub, SQS, SSM, STS, Tags
+- [Amazon Web Services](https://cartography-cncf.github.io/cartography/modules/aws/index.html) - API Gateway, Config, EC2, ECS, ECR, Elasticsearch, Elastic Kubernetes Service (EKS), DynamoDB, IAM, Inspector, KMS, Lambda, RDS, Redshift, Route53, S3, S3AccountPublicAccessBlock, Secrets Manager, Security Hub, SNS, SQS, SSM, STS, Tags
 - [Google Cloud Platform](https://cartography-cncf.github.io/cartography/modules/gcp/index.html) - Cloud Resource Manager, Compute, DNS, Storage, Google Kubernetes Engine
 - [Google GSuite](https://cartography-cncf.github.io/cartography/modules/gsuite/index.html) - users, groups
 - [Oracle Cloud Infrastructure](docs/setup/config/oci.md) - IAM
@@ -172,7 +161,7 @@ Thank you for considering contributing to Cartography!
 All contributors and participants of this project must follow the  [CNCF code of conduct](https://github.com/cncf/foundation/blob/main/code-of-conduct.md).
 
 ### Bug reports and feature requests and discussions
-Submit a GitHub issue to report a bug or request a new feature. If we decide that the issue needs more discussion - usually because the scope is too large or we need to make careful decision - we will convert the issue to a [GitHub Discussion](https://github.com/lyft/cartography/discussions).
+Submit a GitHub issue to report a bug or request a new feature. If we decide that the issue needs more discussion - usually because the scope is too large or we need to make careful decision - we will convert the issue to a [GitHub Discussion](https://github.com/cartography-cncf/cartography/discussions).
 
 ### Developing Cartography