django-slack-tools 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

django_slack_tools/slack_messages/admin/message_recipient.py

@@ -6,13 +6,13 @@ from typing import TYPE_CHECKING, cast
 from django.contrib import admin, messages
 from django.contrib.admin.filters import DateFieldListFilter
 from django.db.models import Count
-from django.db.models.query import QuerySet
 from django.utils.translation import gettext_lazy as _
 
 from django_slack_tools.app_settings import app_settings
 from django_slack_tools.slack_messages.models import SlackMessageRecipient
 
 if TYPE_CHECKING:
+    from django.db.models.query import QuerySet
     from django.http import HttpRequest
 
     class SlackMessageRecipientWithAnnotates(SlackMessageRecipient):  # noqa: D101
@@ -25,7 +25,7 @@ class SlackMessageRecipientAdmin(admin.ModelAdmin):
 
     def get_queryset(self, request: HttpRequest) -> QuerySet[SlackMessageRecipientWithAnnotates]:  # noqa: D102
         return cast(
-            QuerySet["SlackMessageRecipientWithAnnotates"],  # Unsafe force type casting
+            "QuerySet[SlackMessageRecipientWithAnnotates]",  # Unsafe force type casting
             super()
             .get_queryset(request)
             .annotate(

django_slack_tools/slack_messages/admin/messaging_policy.py

@@ -7,15 +7,15 @@ from django.contrib import admin
 from django.contrib.admin.filters import DateFieldListFilter
 from django.db import models
 from django.db.models import Count
-from django.db.models.query import QuerySet
 from django.utils.html import format_html
 from django.utils.translation import gettext_lazy as _
 
 from django_slack_tools.slack_messages.models import SlackMessagingPolicy
+from django_slack_tools.utils.django.widgets import JSONWidget
 from django_slack_tools.utils.slack import get_block_kit_builder_url
-from django_slack_tools.utils.widgets import JSONWidget
 
 if TYPE_CHECKING:
+    from django.db.models.query import QuerySet
     from django.http import HttpRequest
     from django_stubs_ext import StrOrPromise
 
@@ -35,7 +35,7 @@ class SlackMessagingPolicyAdmin(admin.ModelAdmin):
 
     def get_queryset(self, request: HttpRequest) -> QuerySet[SlackMessagingPolicyWithAnnotates]:  # noqa: D102
         return cast(
-            QuerySet["SlackMessagingPolicyWithAnnotates"],  # Unsafe force type casting
+            "QuerySet[SlackMessagingPolicyWithAnnotates]",  # Unsafe force type casting
             super()
             .get_queryset(request)
             .annotate(
@@ -90,7 +90,7 @@ class SlackMessagingPolicyAdmin(admin.ModelAdmin):
     # ------------------------------------------------------------------------
     date_hierarchy = "last_modified"
     search_fields = ("code",)
-    list_display = ("id", "code", "enabled", "_count_recipients", "created", "last_modified")
+    list_display = ("id", "code", "enabled", "_count_recipients", "template_type", "created", "last_modified")
     list_display_links = ("id", "code")
     list_filter = (
         "enabled",
@@ -107,7 +107,7 @@ class SlackMessagingPolicyAdmin(admin.ModelAdmin):
         (
             None,
             {
-                "fields": ("code", "enabled", "recipients", "header_defaults", "template"),
+                "fields": ("code", "enabled", "recipients", "header_defaults", "template_type", "template"),
             },
         ),
         (

django_slack_tools/slack_messages/backends/__init__.py

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

django_slack_tools/slack_messages/backends/base.py

@@ -2,228 +2,64 @@
 
 from __future__ import annotations
 
-import dataclasses
 import traceback
 from abc import ABC, abstractmethod
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Optional, 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
+from django_slack_tools.slack_messages.response import MessageResponse
 
 if TYPE_CHECKING:
     from slack_sdk.web import SlackResponse
 
-    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
+    from django_slack_tools.slack_messages.request import MessageBody, MessageHeader, MessageRequest
 
-logger = getLogger(__name__)
 
-RESERVED_CONTEXT_KWARGS = frozenset({"policy", "mentions", "mentions_as_str"})
-"""Set of reserved context keys automatically created."""
+logger = getLogger(__name__)
 
 
 class BaseBackend(ABC):
     """Abstract base class for messaging backends."""
 
-    def prepare_message(
-        self,
-        *,
-        policy: SlackMessagingPolicy | None = None,
-        channel: str,
-        header: MessageHeader,
-        body: MessageBody,
-    ) -> SlackMessage:
-        """Prepare message.
-
-        Args:
-            policy: Related policy instance.
-            channel: Channel to send message.
-            header: Slack message control header.
-            body: Slack message body.
-
-        Returns:
-            Prepared message.
-        """
-        _header: dict = policy.header_defaults if policy else {}
-        _header.update(dataclasses.asdict(header))
-
-        _body = dataclasses.asdict(body)
-
-        return SlackMessage(policy=policy, channel=channel, header=_header, body=_body)
-
-    def prepare_messages_from_policy(
-        self,
-        policy: SlackMessagingPolicy,
-        *,
-        header: MessageHeader,
-        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:
+    def deliver(self, request: MessageRequest) -> MessageResponse:
+        """Deliver message request."""
+        if request.body is None:
+            msg = "Message body is required."
+            raise ValueError(msg)
 
-        - `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:
-        """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
+            response = self._send_message(
+                channel=request.channel,
+                header=request.header,
+                body=request.body,
+            )
+            error = None
+        except SlackApiError as err:
+            response = err.response
+            error = traceback.format_exc()
+
+        ok = cast("bool", response.get("ok"))
+        data: Any
+        if ok:
+            ts = cast("Optional[str]", response.get("ts", None))
+            data = response.get("message", {})
+            parent_ts = data.get("thread_ts", None)
+        else:
+            ts = None
+            data = response.data
+            parent_ts = None
+
+        return MessageResponse(
+            request=request,
+            ok=ok,
+            error=error,
+            data=data,
+            ts=ts,
+            parent_ts=parent_ts,
+        )
 
     @abstractmethod
-    def _send_message(self, message: SlackMessage) -> SlackResponse:
+    def _send_message(self, *, channel: str, header: MessageHeader, body: MessageBody) -> 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."""
-
-    @abstractmethod
-    def _record_response(self, response: SlackResponse) -> Any:
-        """Extract response data to be recorded. Should return JSON-serializable object."""

django_slack_tools/slack_messages/backends/dummy.py

@@ -7,8 +7,6 @@ from typing import Any
 
 from slack_sdk.web import SlackResponse
 
-from django_slack_tools.slack_messages.models import SlackMessage
-
 from .base import BaseBackend
 
 logger = getLogger(__name__)
@@ -17,9 +15,6 @@ logger = getLogger(__name__)
 class DummyBackend(BaseBackend):
     """An dummy backend that does nothing with message."""
 
-    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(
             client=None,
@@ -30,10 +25,3 @@ class DummyBackend(BaseBackend):
             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/{logging.py → logging_.py}

@@ -20,9 +20,3 @@ class LoggingBackend(DummyBackend):
     def _send_message(self, *args: Any, **kwargs: Any) -> SlackResponse:
         logger.debug("Sending an message with following args=%r, kwargs=%r", args, kwargs)
         return super()._send_message(*args, **kwargs)
-
-    def _record_request(self, *args: Any, **kwargs: Any) -> Any:
-        logger.debug("Recording request with args=%r, kwargs=%r", args, kwargs)
-
-    def _record_response(self, *args: Any, **kwargs: Any) -> Any:
-        logger.debug("Recording response with args=%r, kwargs=%r", args, kwargs)

django_slack_tools/slack_messages/backends/slack.py

@@ -3,21 +3,18 @@
 from __future__ import annotations
 
 from logging import getLogger
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
-from django.core.exceptions import ImproperlyConfigured
 from django.utils.module_loading import import_string
 from django.utils.translation import gettext_lazy as _
 from slack_bolt import App
-from slack_sdk.errors import SlackApiError
 
 from .base import BaseBackend
 
 if TYPE_CHECKING:
     from slack_sdk.web import SlackResponse
 
-    from django_slack_tools.slack_messages.models import SlackMessage
-    from django_slack_tools.utils.slack import MessageBody
+    from django_slack_tools.slack_messages.request import MessageBody, MessageHeader
 
 
 logger = getLogger(__name__)
@@ -26,11 +23,7 @@ logger = getLogger(__name__)
 class SlackBackend(BaseBackend):
     """Backend actually sending the messages."""
 
-    def __init__(
-        self,
-        *,
-        slack_app: App | Callable[[], App] | str,
-    ) -> None:
+    def __init__(self, *, slack_app: App | str) -> None:
         """Initialize backend.
 
         Args:
@@ -39,57 +32,18 @@ class SlackBackend(BaseBackend):
         if isinstance(slack_app, str):
             slack_app = import_string(slack_app)
 
-        if callable(slack_app):
-            slack_app = slack_app()
-
         if not isinstance(slack_app, App):
-            msg = "Couldn't resolve provided app spec into Slack app instance."
-            raise ImproperlyConfigured(msg)
+            msg = f"Expected {App!s} instance, got {type(slack_app)}"
+            raise TypeError(msg)
 
         self._slack_app = slack_app
 
-    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 _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=message.channel,
-                message_ts=message.ts,
-            )
-        except SlackApiError:
-            if raise_exception:
-                raise
-
-            logger.exception(
-                "Error occurred while sending retrieving message's permalink,"
-                " but ignored as `raise_exception` not set.",
-            )
-            return ""
-
-        return _permalink_resp.get("permalink", default="")
-
-    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)
-
-        return response.req_args
-
-    def _record_response(self, response: SlackResponse) -> dict[str, Any]:
-        return {
-            "http_verb": response.http_verb,
-            "api_url": response.api_url,
-            "status_code": response.status_code,
-            "headers": response.headers,
-            "data": response.data,
-        }
+    def _send_message(self, *, channel: str, header: MessageHeader, body: MessageBody) -> SlackResponse:
+        return self._slack_app.client.chat_postMessage(
+            channel=channel,
+            **header.model_dump(),
+            **body.model_dump(),
+        )
 
 
 class SlackRedirectBackend(SlackBackend):
@@ -109,27 +63,19 @@ class SlackRedirectBackend(SlackBackend):
 
         super().__init__(slack_app=slack_app)
 
-    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
+    def _send_message(self, *, channel: str, header: MessageHeader, body: MessageBody) -> SlackResponse:
         if self.inform_redirect:
-            body.attachments = [
+            attachments = body.attachments or []
+            attachments.append(
                 self._make_inform_attachment(original_channel=channel),
-                *(body.attachments or []),
-            ]
+            )
+            body.attachments = attachments
 
-        return super().prepare_message(*args, channel=self.redirect_channel, body=body, **kwargs)
+        return self._slack_app.client.chat_postMessage(
+            channel=self.redirect_channel,
+            **header.model_dump(),
+            **body.model_dump(),
+        )
 
     def _make_inform_attachment(self, *, original_channel: str) -> dict[str, Any]:
         msg_redirect_inform = _(

django_slack_tools/slack_messages/message_templates/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseTemplate
+from .django import DjangoTemplate
+from .python import PythonTemplate
+
+__all__ = ("BaseTemplate", "DjangoTemplate", "PythonTemplate")

django_slack_tools/slack_messages/message_templates/base.py

@@ -0,0 +1,17 @@
+# noqa: D100
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+
+_T = TypeVar("_T")
+
+
+class BaseTemplate(ABC, Generic[_T]):
+    """Base class for templates."""
+
+    template: _T
+
+    @abstractmethod
+    def render(self, context: dict[str, Any]) -> Any:
+        """Render the template with the given context."""

django_slack_tools/{utils/template → slack_messages/message_templates}/django.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from typing import Any
 
     from django.template.backends.base import BaseEngine
+    from django.template.base import Template
 
 logger = logging.getLogger(__name__)
 
@@ -23,6 +24,8 @@ logger = logging.getLogger(__name__)
 class DjangoTemplate(BaseTemplate):
     """Template utilizing Django built-in template engine."""
 
+    template: Template
+
     @overload
     def __init__(self, *, file: str, engine: BaseEngine | None = None) -> None: ...  # pragma: no cover
 
@@ -45,7 +48,6 @@ class DjangoTemplate(BaseTemplate):
 
         Raises:
             TypeError: Some of the arguments are missing or multiple are provided.
-            ValueError: Unsupported value provided.
         """
         engine = engines["django"] if engine is None else engine
 
@@ -61,13 +63,11 @@ class DjangoTemplate(BaseTemplate):
             msg = "Unreachable code"
             raise NotImplementedError(msg)
 
-        self.template = template
-
-    def render(self, *, context: dict[str, Any] | None = None) -> dict:  # noqa: D102
-        context = {} if context is None else context
+        self.template = template  # type: ignore[assignment] # False-positive error
 
+    def render(self, context: dict[str, Any]) -> Any:  # noqa: D102
         logger.debug("Rendering template with context: %r", context)
-        rendered = self.template.render(context=context)
+        rendered = self.template.render(context=context)  # type: ignore[arg-type] # False-positive error
         return _xml_to_dict(rendered)
 
 
@@ -93,7 +93,7 @@ def _xml_to_dict(xml: str) -> dict:
         xml,
         attr_prefix="",
         cdata_key="text",
-        force_list=("blocks", "elements"),
+        force_list=("blocks", "elements", "options"),
         postprocessor=_xml_postprocessor,
     )
     return dict(next(iter(obj.values())))
@@ -101,11 +101,11 @@ def _xml_to_dict(xml: str) -> dict:
 
 def _preprocess_xml(xml: str) -> str:
     """Normalize XML text nodes."""
-    root = ET.fromstring(xml)  # noqa: S314; TODO(lasuillard): Naive belief that XML is safe
+    root = ET.fromstring(xml)  # noqa: S314 ; TODO(lasuillard): Naive belief that XML is safe
     for node in root.iter():
         node.tag = _rename_tag(node.tag)
 
-        if node.tag == "text" and node.text:
+        if node.tag in ("text", "elements") and node.text:
             text = dedent(node.text)
             text = _remove_single_newline(text)
             logger.debug("Normalized text node: %r -> %r", node.text, text)
@@ -114,22 +114,6 @@ def _preprocess_xml(xml: str) -> str:
     return ET.tostring(root, encoding="unicode")
 
 
-def _rename_tag(tag: str) -> str:
-    """Rename tags."""
-    if tag == "block":
-        return "blocks"
-
-    if tag == "element":
-        return "elements"
-
-    return tag
-
-
-def _remove_single_newline(text: str) -> str:
-    """Remove a single newline from repeated newlines. If the are just one newline, replace it with space."""
-    return re.sub(r"([\n]+)", lambda m: "\n" * (m.group(1).count("\n") - 1) or " ", text)
-
-
 def _xml_postprocessor(path: Any, key: str, value: Any) -> tuple[str, Any]:  # noqa: ARG001
     if value == "true":
         return key, True
@@ -137,4 +121,25 @@ def _xml_postprocessor(path: Any, key: str, value: Any) -> tuple[str, Any]:  # n
     if value == "false":
         return key, False
 
+    # TODO(lasuillard): Should coerce all numeric-like strings to numbers?
+    if key == "indent":
+        return key, int(value)
+
     return key, value
+
+
+_TAG_MAPPING = {
+    "block": "blocks",
+    "element": "elements",
+    "option": "options",
+}
+
+
+def _rename_tag(tag: str) -> str:
+    """Rename tags."""
+    return _TAG_MAPPING.get(tag, tag)
+
+
+def _remove_single_newline(text: str) -> str:
+    """Remove a single newline from repeated newlines. If the are just one newline, replace it with space."""
+    return re.sub(r"([\n]+)", lambda m: "\n" * (m.group(1).count("\n") - 1) or " ", text)