feat: add optional extras for cloud storage and notification clients

Add pip extras (s3, gcs, azure, slack, teams) for optional dependencies.
Make all cloud/notification imports lazy to prevent unconditional loading.
Dependencies remain in default install for backwards compatibility (Phase 1).

Closes #2155

Co-Authored-By: Itamar Hartstein <haritamar@gmail.com>

Author: devin-ai-integration[bot]

elementary/clients/azure/client.py

@@ -1,10 +1,9 @@
 from os import path
 from typing import Optional, Tuple
 
-from azure.storage.blob import BlobServiceClient
-
 from elementary.config.config import Config
 from elementary.tracking.tracking_interface import Tracking
+from elementary.utils.deps import import_optional_dependency
 from elementary.utils.log import get_logger
 
 logger = get_logger(__name__)
@@ -13,7 +12,8 @@
 class AzureClient:
     def __init__(self, config: Config, tracking: Optional[Tracking] = None):
         self.config = config
-        self.blob_service_client = BlobServiceClient.from_connection_string(
+        azure_blob = import_optional_dependency("azure.storage.blob", "azure")
+        self.blob_service_client = azure_blob.BlobServiceClient.from_connection_string(
             self.config.azure_connection_string
         )
         self.tracking = tracking

elementary/clients/gcs/client.py

@@ -2,14 +2,10 @@
 from typing import Optional, Tuple
 from urllib.parse import urljoin
 
-import google  # type: ignore[import]
-from google.auth.credentials import Credentials  # type: ignore[import]
-from google.cloud import storage  # type: ignore[attr-defined, import]
-from google.oauth2 import service_account  # type: ignore[import]
-
 from elementary.config.config import Config
 from elementary.tracking.tracking_interface import Tracking
 from elementary.utils import bucket_path
+from elementary.utils.deps import import_optional_dependency
 from elementary.utils.log import get_logger
 
 logger = get_logger(__name__)
@@ -87,16 +83,21 @@ def get_bucket_website_url(
         return bucket_website_url
 
     def get_client(self, config: Config):
+        storage = import_optional_dependency("google.cloud.storage", "gcs")
         creds = self.get_credentials(config)
         if config.google_project_name:
             return storage.Client(config.google_project_name, credentials=creds)
         return storage.Client(credentials=creds)
 
     @staticmethod
-    def get_credentials(config: Config) -> Credentials:
+    def get_credentials(config: Config):
         if config.google_service_account_path:
+            service_account = import_optional_dependency(
+                "google.oauth2.service_account", "gcs"
+            )
             return service_account.Credentials.from_service_account_file(
                 config.google_service_account_path
             )
-        credentials, _ = google.auth.default()
+        google_auth = import_optional_dependency("google.auth", "gcs")
+        credentials, _ = google_auth.default()
         return credentials

elementary/clients/s3/client.py

@@ -1,11 +1,10 @@
 from os import path
 from typing import Optional, Tuple
 
-import boto3
-
 from elementary.config.config import Config
 from elementary.tracking.tracking_interface import Tracking
 from elementary.utils import bucket_path
+from elementary.utils.deps import import_optional_dependency
 from elementary.utils.log import get_logger
 
 logger = get_logger(__name__)
@@ -14,6 +13,7 @@
 class S3Client:
     def __init__(self, config: Config, tracking: Optional[Tracking] = None):
         self.config = config
+        boto3 = import_optional_dependency("boto3", "s3")
         aws_session = boto3.Session(
             profile_name=config.aws_profile_name,
             region_name=config.aws_region_name,

elementary/clients/slack/client.py

@@ -1,18 +1,21 @@
+from __future__ import annotations
+
 import json
 import ssl
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from slack_sdk.errors import SlackApiError
+    from slack_sdk.webhook import WebhookResponse
 
 import requests
 from ratelimit import limits, sleep_and_retry
-from slack_sdk import WebClient, WebhookClient
-from slack_sdk.errors import SlackApiError
-from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
-from slack_sdk.webhook.webhook_response import WebhookResponse
 
 from elementary.clients.slack.schema import SlackMessageSchema
 from elementary.config.config import Config
 from elementary.tracking.tracking_interface import Tracking
+from elementary.utils.deps import import_optional_dependency
 from elementary.utils.log import get_logger
 from elementary.utils.ssl import create_ssl_context
 
@@ -59,7 +62,10 @@ def _initial_client(self, ssl_context: Optional[ssl.SSLContext]):
         raise NotImplementedError
 
     def _initial_retry_handlers(self):
-        if isinstance(self.client, WebClient):
+        slack_sdk = import_optional_dependency("slack_sdk", "slack")
+        if isinstance(self.client, slack_sdk.WebClient):
+            from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
+
             rate_limit_handler = RateLimitErrorRetryHandler(max_retry_count=5)
             self.client.retry_handlers.append(rate_limit_handler)
 
@@ -96,13 +102,16 @@ def __init__(
         super().__init__(tracking, ssl_context)
 
     def _initial_client(self, ssl_context: Optional[ssl.SSLContext]):
-        return WebClient(token=self.token, ssl=ssl_context)
+        slack_sdk = import_optional_dependency("slack_sdk", "slack")
+        return slack_sdk.WebClient(token=self.token, ssl=ssl_context)
 
     @sleep_and_retry
     @limits(calls=1, period=ONE_SECOND)
     def send_message(
         self, channel_name: str, message: SlackMessageSchema, **kwargs
     ) -> bool:
+        from slack_sdk.errors import SlackApiError
+
         try:
             self.client.chat_postMessage(
                 channel=channel_name,
@@ -128,6 +137,8 @@ def send_file(
         file_path: str,
         message: Optional[SlackMessageSchema] = None,
     ) -> bool:
+        from slack_sdk.errors import SlackApiError
+
         channel_id = self._get_channel_id(channel_name)
         try:
             self.client.files_upload_v2(
@@ -157,6 +168,8 @@ def send_report(self, channel_name: str, report_file_path: str):
     @sleep_and_retry
     @limits(calls=50, period=ONE_MINUTE)
     def get_user_id_from_email(self, email: str) -> Optional[str]:
+        from slack_sdk.errors import SlackApiError
+
         try:
             if email not in self.email_to_user_id_cache:
                 user_id = self.client.users_lookupByEmail(email=email)["user"]["id"]
@@ -197,6 +210,8 @@ def _get_channel_id(self, channel_name: str) -> Optional[str]:
                 return None
 
     def _join_channel(self, channel_id: str) -> bool:
+        from slack_sdk.errors import SlackApiError
+
         try:
             self.client.conversations_join(channel=channel_id)
             logger.info("Elementary app joined the channel successfully.")
@@ -249,7 +264,8 @@ def _initial_client(self, ssl_context: Optional[ssl.SSLContext]):
             # requests.Session() uses the requests default CA bundle (certifi).
             return requests.Session()
 
-        return WebhookClient(
+        slack_sdk = import_optional_dependency("slack_sdk", "slack")
+        return slack_sdk.WebhookClient(
             url=self.webhook,
             default_headers={"Content-type": "application/json"},
             ssl=ssl_context,

elementary/clients/slack/slack_message_builder.py

@@ -1,12 +1,14 @@
 from enum import Enum
 from typing import List, Optional, Union
 
-from slack_sdk.models.blocks import HeaderBlock, SectionBlock
-
 from elementary.clients.slack.schema import SlackBlocksType, SlackMessageSchema
 from elementary.utils.json_utils import unpack_and_flatten_str_to_list
 from elementary.utils.pydantic_shim import BaseModel
 
+# Slack Block Kit limits (avoid module-level slack_sdk import)
+_HEADER_TEXT_MAX_LENGTH = 150
+_SECTION_TEXT_MAX_LENGTH = 3000
+
 
 class OptionSchema(BaseModel):
     value: str
@@ -56,11 +58,11 @@ def _add_blocks_as_attachments(self, blocks: SlackBlocksType):
 
     @staticmethod
     def get_limited_markdown_msg(section_msg: str) -> str:
-        if len(section_msg) < SectionBlock.text_max_length:
+        if len(section_msg) < _SECTION_TEXT_MAX_LENGTH:
             return section_msg
         return (
             section_msg[
-                : SectionBlock.text_max_length
+                : _SECTION_TEXT_MAX_LENGTH
                 - len(SlackMessageBuilder._CONTINUATION_SYMBOL)
                 - SlackMessageBuilder._LONGEST_MARKDOWN_SUFFIX_LEN
             ]
@@ -120,8 +122,8 @@ def create_context_block(context_msgs: list) -> dict:
 
     @staticmethod
     def create_header_block(msg: str) -> dict:
-        if len(msg) > HeaderBlock.text_max_length:
-            final_msg = msg[: HeaderBlock.text_max_length - 3] + "..."
+        if len(msg) > _HEADER_TEXT_MAX_LENGTH:
+            final_msg = msg[: _HEADER_TEXT_MAX_LENGTH - 3] + "..."
         else:
             final_msg = msg
 

elementary/config/config.py

@@ -2,9 +2,7 @@
 from pathlib import Path
 from typing import Optional
 
-import google.auth  # type: ignore[import]
 from dateutil import tz
-from google.auth.exceptions import DefaultCredentialsError  # type: ignore[import]
 
 from elementary.exceptions.exceptions import InvalidArgumentsError
 from elementary.monitor.alerts.grouping_type import GroupingType
@@ -265,9 +263,15 @@ def has_gcloud(self):
         if self.google_service_account_path:
             return True
         try:
-            google.auth.default()
+            from elementary.utils.deps import import_optional_dependency
+
+            google_auth = import_optional_dependency("google.auth", "gcs")
+            google_auth.default()
             return True
-        except DefaultCredentialsError:
+        except ImportError:
+            return False
+        except Exception:
+            # google.auth.exceptions.DefaultCredentialsError or similar
             return False
 
     @property

elementary/messages/formats/block_kit.py

@@ -1,7 +1,6 @@
 import json
 from typing import Any, Callable, List, Optional, Tuple
 
-from slack_sdk.models import blocks as slack_blocks
 from tabulate import tabulate
 
 from elementary.messages.blocks import (
@@ -105,11 +104,15 @@ def _format_table_cell(self, cell_value: Any, column_count: int) -> str:
             return value[: max_cell_length - 2] + ".."
         return value
 
+    # Slack Block Kit limits (avoid module-level slack_sdk import)
+    _SECTION_TEXT_MAX_LENGTH = 3000
+    _HEADER_TEXT_MAX_LENGTH = 150
+
     def _format_markdown_section_text(self, text: str) -> dict:
-        if len(text) > slack_blocks.SectionBlock.text_max_length:
+        if len(text) > self._SECTION_TEXT_MAX_LENGTH:
             text = (
                 text[
-                    : slack_blocks.SectionBlock.text_max_length
+                    : self._SECTION_TEXT_MAX_LENGTH
                     - len("...")
                     - self._LONGEST_MARKDOWN_SUFFIX_LEN
                 ]
@@ -198,8 +201,8 @@ def _add_lines_block(self, block: LinesBlock) -> None:
         self._add_block(self._format_markdown_section("\n".join(formatted_lines)))
 
     def _add_header_block(self, block: HeaderBlock) -> None:
-        if len(block.text) > slack_blocks.HeaderBlock.text_max_length:
-            text = block.text[: slack_blocks.HeaderBlock.text_max_length - 3] + "..."
+        if len(block.text) > self._HEADER_TEXT_MAX_LENGTH:
+            text = block.text[: self._HEADER_TEXT_MAX_LENGTH - 3] + "..."
         else:
             text = block.text
         self._add_block(

elementary/messages/messaging_integrations/slack_web.py

@@ -1,14 +1,17 @@
+from __future__ import annotations
+
 import json
 import ssl
 import time
-from typing import Any, Dict, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional
 
 from ratelimit import limits, sleep_and_retry
-from slack_sdk import WebClient
-from slack_sdk.errors import SlackApiError
-from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
 from typing_extensions import TypeAlias
 
+if TYPE_CHECKING:
+    from slack_sdk import WebClient
+    from slack_sdk.errors import SlackApiError
+
 from elementary.messages.formats.block_kit import (
     FormattedBlockKitMessage,
     format_block_kit,
@@ -22,6 +25,7 @@
     MessagingIntegrationError,
 )
 from elementary.tracking.tracking_interface import Tracking
+from elementary.utils.deps import import_optional_dependency
 from elementary.utils.log import get_logger
 from elementary.utils.pydantic_shim import BaseModel
 
@@ -61,7 +65,10 @@ def from_token(
         ssl_context: Optional[ssl.SSLContext] = None,
         **kwargs: Any,
     ) -> "SlackWebMessagingIntegration":
-        client = WebClient(token=token, ssl=ssl_context)
+        slack_sdk = import_optional_dependency("slack_sdk", "slack")
+        from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
+
+        client = slack_sdk.WebClient(token=token, ssl=ssl_context)
         client.retry_handlers.append(RateLimitErrorRetryHandler(max_retry_count=5))
         return cls(client, tracking, **kwargs)
 
@@ -103,6 +110,8 @@ def _send_message(
         thread_ts: Optional[str] = None,
         reply_broadcast: bool = False,
     ) -> MessageSendResult[SlackWebMessageContext]:
+        from slack_sdk.errors import SlackApiError
+
         try:
             response = self.client.chat_postMessage(
                 channel=destination,
@@ -180,6 +189,8 @@ def _get_channel_id(self, channel_name: str, only_public: bool = False) -> str:
         raise MessagingIntegrationError(f"Channel {channel_name} not found")
 
     def _join_channel(self, channel_id: str) -> None:
+        from slack_sdk.errors import SlackApiError
+
         try:
             self.client.conversations_join(channel=channel_id)
         except SlackApiError as e:
@@ -190,6 +201,8 @@ def _join_channel(self, channel_id: str) -> None:
     @sleep_and_retry
     @limits(calls=50, period=ONE_MINUTE)
     def get_user_id_from_email(self, email: str) -> Optional[str]:
+        from slack_sdk.errors import SlackApiError
+
         if email in self._email_to_user_id_cache:
             return self._email_to_user_id_cache[email]
         try:

elementary/messages/messaging_integrations/slack_webhook.py

@@ -1,11 +1,14 @@
+from __future__ import annotations
+
 import ssl
 from datetime import datetime, timezone
 from http import HTTPStatus
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from ratelimit import limits, sleep_and_retry
-from slack_sdk import WebhookClient
-from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
+
+if TYPE_CHECKING:
+    from slack_sdk import WebhookClient
 
 from elementary.messages.formats.block_kit import (
     FormattedBlockKitMessage,
@@ -23,6 +26,7 @@
     MessagingIntegrationError,
 )
 from elementary.tracking.tracking_interface import Tracking
+from elementary.utils.deps import import_optional_dependency
 
 ONE_SECOND = 1
 
@@ -43,7 +47,10 @@ def from_url(
         tracking: Optional[Tracking] = None,
         ssl_context: Optional[ssl.SSLContext] = None,
     ) -> "SlackWebhookMessagingIntegration":
-        client = WebhookClient(url, ssl=ssl_context)
+        slack_sdk = import_optional_dependency("slack_sdk", "slack")
+        from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
+
+        client = slack_sdk.WebhookClient(url, ssl=ssl_context)
         client.retry_handlers.append(RateLimitErrorRetryHandler(max_retry_count=5))
         return cls(client, tracking)