django-slack-tools 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

django_slack_tools/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "0.2.0"

django_slack_tools/app_settings.py

@@ -9,8 +9,9 @@ from django.conf import settings
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.module_loading import import_string
 from slack_bolt import App
+from typing_extensions import NotRequired
 
-from django_slack_tools.slack_messages.backends.base import BackendBase
+from django_slack_tools.slack_messages.backends.base import BaseBackend
 
 APP_SETTINGS_KEY = "DJANGO_SLACK_TOOLS"
 "Django settings key for this application."
@@ -18,10 +19,11 @@ APP_SETTINGS_KEY = "DJANGO_SLACK_TOOLS"
 logger = getLogger(__name__)
 
 
+# TODO(lasuillard): Configuration getting dirty, need refactoring
 class AppSettings:
     """Application settings."""
 
-    backend: BackendBase
+    backend: BaseBackend
 
     def __init__(self, settings_dict: ConfigDict | None = None) -> None:
         """Initialize app settings.
@@ -56,15 +58,26 @@ class AppSettings:
 
         # Find backend class
         messaging_backend = import_string(settings_dict["BACKEND"]["NAME"])
-        if not issubclass(messaging_backend, BackendBase):
+        if not issubclass(messaging_backend, BaseBackend):
             msg = "Provided backend is not a subclass of `{qualified_path}` class.".format(
-                qualified_path=f"{BackendBase.__module__}.{BackendBase.__name__}",
+                qualified_path=f"{BaseBackend.__module__}.{BaseBackend.__name__}",
             )
             raise ImproperlyConfigured(msg)
 
         # Initialize with provided options
         self.backend = messaging_backend(**settings_dict["BACKEND"]["OPTIONS"])
 
+        # Message delivery default
+        self.default_policy_code = settings_dict.get("DEFAULT_POLICY_CODE", "DEFAULT")
+
+        # Lazy policy defaults
+        self.lazy_policy_enabled = settings_dict.get("LAZY_POLICY_ENABLED", False)
+        self.default_template = settings_dict.get(
+            "DEFAULT_POLICY_CODE",
+            {"text": "No template configured for lazily created policy {policy}"},
+        )
+        self.default_recipient = settings_dict.get("DEFAULT_RECIPIENT", "DEFAULT")
+
     @property
     def slack_app(self) -> App:
         """Registered Slack app or `None`."""
@@ -83,6 +96,18 @@ class ConfigDict(TypedDict):
     BACKEND: BackendConfig
     "Nested backend config."
 
+    LAZY_POLICY_ENABLED: NotRequired[bool]
+    "Whether to enable lazy policy by default."
+
+    DEFAULT_POLICY_CODE: NotRequired[str]
+    "Default policy code used when sending messages via policy with no policy specified."
+
+    DEFAULT_TEMPLATE: NotRequired[Any]
+    "Default template for lazy policy."
+
+    DEFAULT_RECIPIENT: NotRequired[str]
+    "Default recipient alias for lazy policy."
+
 
 class BackendConfig(TypedDict):
     """Backend config dict."""

django_slack_tools/slack_messages/admin/message.py

@@ -61,7 +61,7 @@ class SlackMessageAdmin(admin.ModelAdmin):
         n_success = 0
         n_failure = 0
         for message in queryset:
-            backend.send_message(message, raise_exception=False)
+            backend.send_message(message, raise_exception=False, get_permalink=False)
             if message.ok:
                 n_success += 1
             else:

django_slack_tools/slack_messages/apps.py

@@ -9,3 +9,12 @@ class DjangoSlackBotConfig(AppConfig):  # noqa: D101
     default_auto_field = "django.db.models.BigAutoField"
     name = "django_slack_tools.slack_messages"
     verbose_name = _("Slack Messages")
+
+    def ready(self) -> None:  # pragma: no cover
+        """Auto-discover Celery tasks, if Celery is installed."""
+        try:
+            import celery  # noqa: F401
+        except ImportError:
+            pass
+        else:
+            from . import tasks  # noqa: F401

django_slack_tools/slack_messages/backends/__init__.py

@@ -1,10 +1,10 @@
-from .base import BackendBase
+from .base import BaseBackend
 from .dummy import DummyBackend
 from .logging import LoggingBackend
 from .slack import SlackBackend, SlackRedirectBackend
 
 __all__ = (
-    "BackendBase",
+    "BaseBackend",
     "SlackBackend",
     "SlackRedirectBackend",
     "DummyBackend",

django_slack_tools/slack_messages/backends/base.py

@@ -2,89 +2,224 @@
 
 from __future__ import annotations
 
+import dataclasses
+import traceback
 from abc import ABC, abstractmethod
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, overload
+from typing import TYPE_CHECKING, Any, cast
+
+from slack_sdk.errors import SlackApiError
 
 from django_slack_tools.slack_messages.models import SlackMessage, SlackMessagingPolicy
+from django_slack_tools.utils.slack import MessageBody
+from django_slack_tools.utils.template import DictTemplate, DjangoTemplate
 
 if TYPE_CHECKING:
     from slack_sdk.web import SlackResponse
 
-    from django_slack_tools.utils.slack import MessageBody, MessageHeader
+    from django_slack_tools.slack_messages.models.mention import SlackMention
+    from django_slack_tools.slack_messages.models.message_recipient import SlackMessageRecipient
+    from django_slack_tools.utils.slack import MessageHeader
+    from django_slack_tools.utils.template import BaseTemplate
 
 logger = getLogger(__name__)
 
+RESERVED_CONTEXT_KWARGS = frozenset({"policy", "mentions", "mentions_as_str"})
+"""Set of reserved context keys automatically created."""
 
-class BackendBase(ABC):
-    """Abstract base class for messaging backends."""
 
-    @overload
-    def send_message(
-        self,
-        message: SlackMessage,
-        *,
-        raise_exception: bool,
-        get_permalink: bool = False,
-    ) -> SlackMessage: ...  # pragma: no cover
+class BaseBackend(ABC):
+    """Abstract base class for messaging backends."""
 
-    @overload
-    def send_message(
+    def prepare_message(
         self,
         *,
         policy: SlackMessagingPolicy | None = None,
         channel: str,
         header: MessageHeader,
         body: MessageBody,
-        raise_exception: bool,
-        get_permalink: bool = False,
-    ) -> SlackMessage: ...  # pragma: no cover
-
-    @abstractmethod
-    def send_message(  # noqa: PLR0913
-        self,
-        message: SlackMessage | None = None,
-        *,
-        policy: SlackMessagingPolicy | None = None,
-        channel: str | None = None,
-        header: MessageHeader | None = None,
-        body: MessageBody | None = None,
-        raise_exception: bool,
-        get_permalink: bool = False,
     ) -> SlackMessage:
-        """Send Slack message.
+        """Prepare message.
 
         Args:
-            message: Externally prepared message.
-                If not given, make one using `channel`, `header` and `body` parameters.
-            policy: Messaging policy to create message with.
+            policy: Related policy instance.
             channel: Channel to send message.
-            header: Message header that controls how message will sent.
-            body: Message body describing content of the message.
-            raise_exception: Whether to re-raise caught exception while sending messages.
-            get_permalink: Try to get the message permalink via extraneous Slack API calls.
+            header: Slack message control header.
+            body: Slack message body.
 
         Returns:
-            Sent Slack message.
+            Prepared message.
         """
+        _header: dict = policy.header_defaults if policy else {}
+        _header.update(dataclasses.asdict(header))
 
-    def _prepare_message(
+        _body = dataclasses.asdict(body)
+
+        return SlackMessage(policy=policy, channel=channel, header=_header, body=_body)
+
+    def prepare_messages_from_policy(
         self,
+        policy: SlackMessagingPolicy,
         *,
-        policy: SlackMessagingPolicy | None = None,
-        channel: str,
         header: MessageHeader,
-        body: MessageBody,
+        context: dict[str, Any],
+    ) -> list[SlackMessage]:
+        """Prepare messages from policy.
+
+        Args:
+            policy: Policy to create messages from.
+            header: Common message header.
+            context: Message context.
+
+        Returns:
+            Prepared messages.
+        """
+        overridden_reserved = RESERVED_CONTEXT_KWARGS & set(context.keys())
+        if overridden_reserved:
+            logger.warning(
+                "Template keyword argument(s) %s reserved for passing mentions, but already exists."
+                " User provided value will override it.",
+                ", ".join(f"`{s}`" for s in overridden_reserved),
+            )
+
+        messages: list[SlackMessage] = []
+        for recipient in policy.recipients.all():
+            logger.debug("Sending message to recipient %s", recipient)
+
+            # Initialize template instance
+            template = self._get_template_instance_from_policy(policy)
+
+            # Prepare rendering arguments
+            render_context = self._get_default_context(policy=policy, recipient=recipient)
+            render_context.update(context)
+            logger.debug("Context prepared as: %r", render_context)
+
+            # Render template and parse as body
+            rendered = template.render(context=render_context)
+            body = MessageBody.from_any(rendered)
+
+            # Create message instance
+            message = self.prepare_message(policy=policy, channel=recipient.channel, header=header, body=body)
+            messages.append(message)
+
+        return SlackMessage.objects.bulk_create(messages)
+
+    def _get_template_instance_from_policy(self, policy: SlackMessagingPolicy) -> BaseTemplate:
+        """Get template instance."""
+        if policy.template_type == SlackMessagingPolicy.TemplateType.DICT:
+            return DictTemplate(policy.template)
+
+        if policy.template_type == SlackMessagingPolicy.TemplateType.DJANGO:
+            return DjangoTemplate(file=policy.template)
+
+        if policy.template_type == SlackMessagingPolicy.TemplateType.DJANGO_INLINE:
+            return DjangoTemplate(inline=policy.template)
+
+        msg = f"Unsupported template type: {policy.template_type!r}"
+        raise ValueError(msg)
+
+    def _get_default_context(self, *, policy: SlackMessagingPolicy, recipient: SlackMessageRecipient) -> dict[str, Any]:
+        """Get default context for rendering.
+
+        Following default context keys are created:
+
+        - `policy`: Policy code.
+        - `mentions`: List of mentions.
+        - `mentions_as_str`: Comma-separated joined string of mentions.
+        """
+        mentions: list[SlackMention] = list(recipient.mentions.all())
+        mentions_as_str = ", ".join(mention.mention for mention in mentions)
+
+        return {
+            "policy": policy.code,
+            "mentions": mentions,
+            "mentions_as_str": mentions_as_str,
+        }
+
+    def send_messages(self, *messages: SlackMessage, raise_exception: bool, get_permalink: bool) -> int:
+        """Shortcut to send multiple messages.
+
+        Args:
+            messages: Messages to send.
+            raise_exception: Whether to propagate exceptions.
+            get_permalink: Try to get the message permalink via additional Slack API call.
+
+        Returns:
+            Count of messages sent successfully.
+        """
+        num_sent = 0
+        for message in messages:
+            sent = self.send_message(message=message, raise_exception=raise_exception, get_permalink=get_permalink)
+            num_sent += 1 if sent.ok else 0
+
+        return num_sent
+
+    def send_message(
+        self,
+        message: SlackMessage,
+        *,
+        raise_exception: bool,
+        get_permalink: bool,
     ) -> SlackMessage:
-        _header: dict = policy.header_defaults if policy else {}
-        _header.update(header.model_dump(exclude_unset=True))
-        _body = body.model_dump()
-        return SlackMessage(policy=policy, channel=channel, header=_header, body=_body)
+        """Send message.
+
+        Args:
+            message: Prepared message.
+            raise_exception: Whether to propagate exceptions.
+            get_permalink: Try to get the message permalink via additional Slack API call.
+
+        Returns:
+            Message sent to Slack.
+        """
+        try:
+            response: SlackResponse
+            try:
+                response = self._send_message(message)
+            except SlackApiError as err:
+                if raise_exception:
+                    raise
+
+                logger.warning(
+                    "Error occurred while sending message but suppressed because `raise_exception` set.",
+                    exc_info=err,
+                )
+                response = err.response
+
+            message.ok = ok = cast(bool, response.get("ok"))
+            if ok:
+                # Get message TS if OK
+                message.ts = cast(str, response.get("ts"))
+
+                # Store thread TS if possible
+                data: dict[str, Any] = response.get("message", {})
+                message.parent_ts = data.get("thread_ts", "")
+
+                # Get message permalink
+                if get_permalink:
+                    message.permalink = self._get_permalink(message=message, raise_exception=raise_exception)
+
+            message.request = self._record_request(response)
+            message.response = self._record_response(response)
+        except:  # noqa: E722
+            if raise_exception:
+                raise
+
+            logger.exception("Error occurred while sending message but suppressed because `raise_exception` set.")
+            message.exception = traceback.format_exc()
+        finally:
+            message.save()
+
+        message.refresh_from_db()
+        return message
 
     @abstractmethod
-    def _send_message(self, *, message: SlackMessage) -> SlackResponse:
+    def _send_message(self, message: SlackMessage) -> SlackResponse:
         """Internal implementation of actual 'send message' behavior."""
 
+    @abstractmethod
+    def _get_permalink(self, *, message: SlackMessage, raise_exception: bool) -> str:
+        """Get a permalink for given message identifier."""
+
     @abstractmethod
     def _record_request(self, response: SlackResponse) -> Any:
         """Extract request data to be recorded. Should return JSON-serializable object."""

django_slack_tools/slack_messages/backends/dummy.py

@@ -9,20 +9,16 @@ from slack_sdk.web import SlackResponse
 
 from django_slack_tools.slack_messages.models import SlackMessage
 
-from .base import BackendBase
+from .base import BaseBackend
 
 logger = getLogger(__name__)
 
 
-class DummyBackend(BackendBase):
+class DummyBackend(BaseBackend):
     """An dummy backend that does nothing with message."""
 
-    def send_message(self, *args: Any, **kwargs: Any) -> SlackMessage:  # noqa: ARG002
-        """This backend will not do anything, just like dummy."""
-        return SlackMessage()
-
-    def _prepare_message(self, *args: Any, **kwargs: Any) -> SlackMessage:  # noqa: ARG002
-        return SlackMessage()
+    def prepare_message(self, *args: Any, **kwargs: Any) -> SlackMessage:  # noqa: D102, ARG002
+        return SlackMessage(header={}, body={})
 
     def _send_message(self, *args: Any, **kwargs: Any) -> SlackResponse:  # noqa: ARG002
         return SlackResponse(
@@ -30,11 +26,14 @@ class DummyBackend(BackendBase):
             http_verb="POST",
             api_url="https://www.slack.com/api/chat.postMessage",
             req_args={},
-            data={"ok": False},
+            data={"ok": True},
             headers={},
             status_code=200,
         )
 
+    def _get_permalink(self, *, message: SlackMessage, raise_exception: bool) -> str:  # noqa: ARG002
+        return ""
+
     def _record_request(self, *args: Any, **kwargs: Any) -> Any: ...
 
     def _record_response(self, *args: Any, **kwargs: Any) -> Any: ...

django_slack_tools/slack_messages/backends/slack.py

@@ -2,9 +2,8 @@
 
 from __future__ import annotations
 
-import traceback
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, Callable, cast
+from typing import TYPE_CHECKING, Any, Callable
 
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.module_loading import import_string
@@ -12,19 +11,19 @@ from django.utils.translation import gettext_lazy as _
 from slack_bolt import App
 from slack_sdk.errors import SlackApiError
 
-from .base import BackendBase
+from .base import BaseBackend
 
 if TYPE_CHECKING:
     from slack_sdk.web import SlackResponse
 
-    from django_slack_tools.slack_messages.models import SlackMessage, SlackMessagingPolicy
-    from django_slack_tools.utils.slack import MessageBody, MessageHeader
+    from django_slack_tools.slack_messages.models import SlackMessage
+    from django_slack_tools.utils.slack import MessageBody
 
 
 logger = getLogger(__name__)
 
 
-class SlackBackend(BackendBase):
+class SlackBackend(BaseBackend):
     """Backend actually sending the messages."""
 
     def __init__(
@@ -49,88 +48,21 @@ class SlackBackend(BackendBase):
 
         self._slack_app = slack_app
 
-    def send_message(  # noqa: PLR0913
-        self,
-        message: SlackMessage | None = None,
-        *,
-        policy: SlackMessagingPolicy | None = None,
-        channel: str | None = None,
-        header: MessageHeader | None = None,
-        body: MessageBody | None = None,
-        raise_exception: bool,
-        get_permalink: bool = False,
-    ) -> SlackMessage:
-        """Send Slack message.
-
-        Args:
-            message: Externally prepared message.
-                If not given, make one using `channel`, `header` and `body` parameters.
-            policy: Messaging policy to create message with.
-            channel: Channel to send message.
-            header: Message header that controls how message will sent.
-            body: Message body describing content of the message.
-            raise_exception: Whether to re-raise caught exception while sending messages.
-            get_permalink: Try to get the message permalink via extraneous Slack API calls.
-
-        Returns:
-            Sent Slack message.
-        """
-        if not message:
-            if not (channel and header and body):
-                msg = (
-                    "Call signature mismatch for overload."
-                    " If `message` not provided, `channel`, `header` and `body` all must given."
-                )
-                raise TypeError(msg)
-
-            message = self._prepare_message(policy=policy, channel=channel, header=header, body=body)
+    def _send_message(self, message: SlackMessage) -> SlackResponse:
+        header = message.header or {}
+        body = message.body or {}
+        return self._slack_app.client.chat_postMessage(channel=message.channel, **header, **body)
 
-        try:
-            # Send Slack message
-            response: SlackResponse
-            try:
-                response = self._send_message(message=message)
-            except SlackApiError as err:
-                if raise_exception:
-                    raise
-
-                logger.exception(
-                    "Error occurred while sending Slack message, but ignored because `raise_exception` not set.",
-                )
-                response = err.response
-
-            # Update message detail
-            ok: bool | None = response.get("ok")
-            message.ok = ok
-            if ok:
-                # `str` if OK, otherwise `None`
-                message.ts = cast(str, response.get("ts"))
-                message.parent_ts = response.get("message", {}).get("thread_ts", "")  # type: ignore[call-overload]
-                if get_permalink:
-                    message.permalink = self._get_permalink(
-                        channel=message.channel,
-                        message_ts=message.ts,
-                        raise_exception=raise_exception,
-                    )
-
-            message.request = self._record_request(response)
-            message.response = self._record_response(response)
-        except:
-            message.exception = traceback.format_exc()
-
-            # Don't omit raise with flag `raise_exception` here
-            raise
-        finally:
-            message.save()
-
-        return message
-
-    def _get_permalink(self, *, channel: str, message_ts: str, raise_exception: bool = False) -> str:
+    def _get_permalink(self, *, message: SlackMessage, raise_exception: bool = False) -> str:
         """Get a permalink for given message identifier."""
+        if not message.ts:
+            msg = "Message timestamp is not set, can't retrieve permalink."
+            raise ValueError(msg)
+
         try:
             _permalink_resp = self._slack_app.client.chat_getPermalink(
-                channel=channel,
-                message_ts=message_ts,
+                channel=message.channel,
+                message_ts=message.ts,
             )
         except SlackApiError:
             if raise_exception:
@@ -144,11 +76,6 @@ class SlackBackend(BackendBase):
 
         return _permalink_resp.get("permalink", default="")
 
-    def _send_message(self, *, message: SlackMessage) -> SlackResponse:
-        header = message.header or {}
-        body = message.body or {}
-        return self._slack_app.client.chat_postMessage(channel=message.channel, **header, **body)
-
     def _record_request(self, response: SlackResponse) -> dict[str, Any]:
         # Remove auth header (token) from request before recording
         response.req_args.get("headers", {}).pop("Authorization", None)
@@ -182,7 +109,18 @@ class SlackRedirectBackend(SlackBackend):
 
         super().__init__(slack_app=slack_app)
 
-    def _prepare_message(self, *args: Any, channel: str, body: MessageBody, **kwargs: Any) -> SlackMessage:
+    def prepare_message(self, *args: Any, channel: str, body: MessageBody, **kwargs: Any) -> SlackMessage:
+        """Prepare message to send, with modified for redirection.
+
+        Args:
+            args: Positional arguments to pass to super method.
+            channel: Original channel to send message.
+            body: Message content.
+            kwargs: Keyword arguments to pass to super method.
+
+        Returns:
+            Prepared message instance.
+        """
         # Modify channel to force messages always sent to specific channel
         # Add an attachment that informing message has been redirected
         if self.inform_redirect:
@@ -191,7 +129,7 @@ class SlackRedirectBackend(SlackBackend):
                 *(body.attachments or []),
             ]
 
-        return super()._prepare_message(*args, channel=self.redirect_channel, body=body, **kwargs)
+        return super().prepare_message(*args, channel=self.redirect_channel, body=body, **kwargs)
 
     def _make_inform_attachment(self, *, original_channel: str) -> dict[str, Any]:
         msg_redirect_inform = _(