vintasend-celery 0.1.0__tar.gz

vintasend_celery-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Vinta Serviços e Soluções Tecnológicas Ltda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vintasend_celery-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.3
+Name: vintasend-celery
+Version: 0.1.0
+Summary: Celery adapter for VintaSend
+License: MIT
+Author: Hugo bessa
+Author-email: hugo@vinta.com.br
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: celery (>=5.4.0,<6.0.0)
+Requires-Dist: vintasend
+Description-Content-Type: text/markdown
+
+# VintaSend Celery
+
+Celery adapter base implementation for VintaSend. 
+
+This package doesn't implement an actual adapter, but it helps you to make an existing adapter to run from a Celery worker.
+
+
+## Installation
+
+To install VintaSend Celery you need to run the following command:
+
+```shell
+pip install vinstasend vintasend-celery
+```
+
+
+## Quick start
+
+To use VintaSend Celery you need to manually register your tasks

vintasend_celery-0.1.0/README.md

@@ -0,0 +1,19 @@
+# VintaSend Celery
+
+Celery adapter base implementation for VintaSend. 
+
+This package doesn't implement an actual adapter, but it helps you to make an existing adapter to run from a Celery worker.
+
+
+## Installation
+
+To install VintaSend Celery you need to run the following command:
+
+```shell
+pip install vinstasend vintasend-celery
+```
+
+
+## Quick start
+
+To use VintaSend Celery you need to manually register your tasks

vintasend_celery-0.1.0/pyproject.toml

@@ -0,0 +1,161 @@
+[tool.poetry]
+name = "vintasend-celery"
+version = "0.1.0"
+description = "Celery adapter for VintaSend"
+authors = ["Hugo bessa <hugo@vinta.com.br>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "<3.13,>=3.10"
+vintasend = "*"
+celery = "^5.4.0"
+
+
+[tool.poetry.group.dev.dependencies]
+coverage = "^7.6.4"
+tox = "^4.23.2"
+pytest = "^8.3.3"
+pytest-xdist = {version = "^3.6.1", extras=["psutil"]}
+coveralls = "^4.0.1"
+pytest-cov = "^6.0.0"
+pytest-celery = "^1.1.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.ruff]
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pep8-naming
+    "N",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-bandit
+    "S",
+    # flake8-blind-except
+    "BLE",
+    # flake8-builtins
+    "A",
+    # flake8-django
+    "DJ",
+    # isort
+    "I",
+    # flake8-logging-format
+    "G",
+    # flake8-no-pep420
+    "INP",
+    # Ruff-specific rules
+    "RUF",
+]
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "virtualenvs",
+    "*/migrations/*",
+]
+ignore = [
+    # Disable eradicate (commented code removal)
+    "ERA001",
+    # Disable Conflicting lint rules,
+    # see https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules
+    "W191",
+    "E501",
+    "E111",
+    "E117",
+    "D206",
+    "D300",
+    "Q000",
+    "Q001",
+    "Q002",
+    "Q003",
+    "COM812",
+    "COM819",
+    "ISC001",
+    "ISC002",
+    # Allow `except Exception`:
+    "BLE001",
+    # Disable unused `noqa` directive
+    "RUF100",
+    # Disable pyupgrade UP rules that conflict with django-ninja
+    "UP006",
+    "UP035",
+    "UP037",
+    "UP040",
+]
+line-length = 100
+indent-width = 4
+target-version = "py312"
+# Allow unused variables when underscore-prefixed:
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.pycodestyle]
+ignore-overlong-task-comments = true
+
+[tool.ruff.lint.isort]
+section-order = [
+    "future",
+    "standard-library",
+    "django",
+    "third-party",
+    "first-party",
+    "local-folder",
+]
+lines-after-imports = 2
+
+[tool.ruff.lint.isort.sections]
+# Group all Django imports into a separate section.
+"django" = ["django"]
+
+[tool.ruff.per-file-ignores]
+# Ignore "E402", "F403", "F405" (import violations) in __init__.py files.
+# Ignore "S" (flake8-bandit) and "N802" (function name should be lowercase) in tests and docs.
+# Ignore "RUF" (Ruff-specific rules) and "I" (isort) in migrations.
+"__init__.py" = ["E402", "F403", "F405"]
+"**/{tests,docs}/*" = ["E402", "F403", "F405", "S", "N802"]
+"**/*test*.py" = ["E402", "F403", "F405", "S", "N802"]
+"**/{settings}/*" = ["E402", "F403", "F405"]
+"**/migrations/*" = ["RUF", "I"]
+
+[tool.coverage.run]
+branch = true
+source = ["backend"]
+omit = [
+    "**/venv/*",
+    "**/env/*",
+    "**/virtualenvs/*",
+    "**/node_modules/*",
+    "**/migrations/*",
+    "**/settings/*",
+    "**/tests/*",
+]
+
+[tool.pytest.ini_options]
+python_files = ["test_*.py"]
+addopts = "--dist=loadscope"

vintasend_celery-0.1.0/vintasend_celery/services/notification_adapters/celery_adapter_factory.py

@@ -0,0 +1,92 @@
+import datetime
+import uuid
+from typing import Generic, TypeVar, cast
+
+from celery import Task  # type: ignore
+from vintasend.services.dataclasses import Notification, NotificationContextDict
+from vintasend.services.notification_adapters.async_base import (
+    AsyncBaseNotificationAdapter,
+    NotificationDict,
+)
+from vintasend.services.notification_backends.base import BaseNotificationBackend
+from vintasend.services.notification_template_renderers.base import BaseNotificationTemplateRenderer
+
+
+B = TypeVar("B", bound=BaseNotificationBackend)
+T = TypeVar("T", bound=BaseNotificationTemplateRenderer)
+
+
+class CeleryNotificationAdapter(Generic[B, T], AsyncBaseNotificationAdapter[B, T]):
+    send_notification_task: Task
+
+    def delayed_send(self, notification_dict: NotificationDict, context_dict: dict) -> None:
+        notification = self.notification_from_dict(notification_dict)
+        context = NotificationContextDict(**context_dict)
+        super().send(notification, context)  # type: ignore
+
+    def notification_to_dict(self, notification: "Notification") -> NotificationDict:
+        non_serializable_fields = ["send_after"]
+        serialized_notification = {}
+        for field in notification.__dataclass_fields__.keys():
+            if field in non_serializable_fields:
+                continue
+            serialized_notification[field] = getattr(notification, field)
+
+        serialized_notification["send_after"] = (
+            notification.send_after.isoformat() if notification.send_after else None
+        )
+
+        return cast(NotificationDict, serialized_notification)
+
+    def _convert_to_uuid(self, value: str) -> uuid.UUID | str:
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            return value
+
+    def notification_from_dict(self, notification_dict: NotificationDict) -> "Notification":
+        send_after = (
+            datetime.datetime.fromisoformat(notification_dict["send_after"])
+            if notification_dict["send_after"]
+            else None
+        )
+        return Notification(
+            id=(
+                self._convert_to_uuid(notification_dict["id"])
+                if isinstance(notification_dict["id"], str)
+                else notification_dict["id"]
+            ),
+            user_id=(
+                self._convert_to_uuid(notification_dict["user_id"])
+                if isinstance(notification_dict["user_id"], str)
+                else notification_dict["user_id"]
+            ),
+            context_kwargs={
+                key: self._convert_to_uuid(value) if isinstance(value, str) else value
+                for key, value in notification_dict["context_kwargs"].items()
+            },
+            notification_type=notification_dict["notification_type"],
+            title=notification_dict["title"],
+            body_template=notification_dict["body_template"],
+            context_name=notification_dict["context_name"],
+            subject_template=notification_dict["subject_template"],
+            preheader_template=notification_dict["preheader_template"],
+            status=notification_dict["status"],
+            context_used=notification_dict["context_used"],
+            send_after=send_after,
+        )
+
+    def send(self, notification: "Notification", context: "NotificationContextDict") -> None:
+        self.send_notification_task.delay(
+            notification=self.notification_to_dict(notification),
+            context=context,
+            backend=self.backend.backend_import_str,
+            adapters=[
+                (
+                    self.adapter_import_str,
+                    self.template_renderer.template_renderer_import_str,
+                )
+            ],
+            backend_kwargs=self.backend.backend_kwargs,
+            config=self.serialize_config(),
+        )

vintasend_celery-0.1.0/vintasend_celery/tasks/background_tasks.py

@@ -0,0 +1,11 @@
+import logging
+
+from celery import Celery  # type: ignore
+from vintasend.tasks.background_tasks import send_notification
+
+
+logger = logging.getLogger(__name__)
+
+
+def send_notification_task_factory(celery_app: Celery):
+    return celery_app.task(send_notification)

vintasend_celery-0.1.0/vintasend_celery/tasks/periodic_tasks.py

@@ -0,0 +1,6 @@
+from celery import Celery  # type: ignore
+from vintasend.tasks.periodic_tasks import periodic_send_pending_notifications
+
+
+def periodic_send_pending_notifications_task_factory(celery_app: Celery):
+    return celery_app.task(periodic_send_pending_notifications)

vintasend_celery-0.1.0/vintasend_celery/tests/test_services/test_adapters.py

@@ -0,0 +1,136 @@
+import uuid
+from unittest.mock import patch
+
+import pytest
+from vintasend.constants import NotificationStatus, NotificationTypes
+from vintasend.services.dataclasses import Notification
+from vintasend.services.notification_backends.stubs.fake_backend import (
+    Config,
+    FakeFileBackend,
+    FakeFileBackendWithNonSerializableKWArgs,
+)
+from vintasend.services.notification_service import NotificationService, register_context
+from vintasend.services.notification_template_renderers.stubs.fake_templated_email_renderer import (
+    FakeTemplateRenderer,
+    FakeTemplateRendererWithException,
+)
+
+from example_app.celery import (
+    AsyncCeleryFakeEmailAdapter,
+    AsyncCeleryFakeEmailAdapterWithBackendWithNonSerializableKWArgs,
+)
+
+
+@pytest.fixture()
+def celery_app():
+    from example_app.celery import celery_app
+    celery_app.conf.update(task_always_eager=True)
+    return celery_app
+
+
+@pytest.fixture(scope="function")
+def notification_backend():
+    backend = FakeFileBackend(database_file_name="celery-adapter-tests-notifications.json")
+    yield backend
+    backend.clear()
+
+
+@pytest.fixture()
+def renderer():
+    return FakeTemplateRenderer()
+
+
+@pytest.fixture()
+def notification_service(notification_backend, renderer):
+    async_adapter = AsyncCeleryFakeEmailAdapter(
+        template_renderer=renderer, backend=notification_backend
+    )
+
+    notification_service = NotificationService[AsyncCeleryFakeEmailAdapter, FakeFileBackend](
+        [async_adapter],
+        notification_backend,
+    )
+
+    return notification_service
+
+
+def create_notification():
+    register_context("test_context")(create_notification_context)
+    return Notification(
+        id=uuid.uuid4(),
+        user_id=1,
+        notification_type=NotificationTypes.EMAIL.value,
+        title="Test Notification",
+        body_template="vintasend_django/emails/test/test_templated_email_body.html",
+        context_name="test_context",
+        context_kwargs={"test": "test"},
+        send_after=None,
+        subject_template="vintasend_django/emails/test/test_templated_email_subject.txt",
+        preheader_template="vintasend_django/emails/test/test_templated_email_preheader.html",
+        status=NotificationStatus.PENDING_SEND.value,
+    )
+
+
+def create_notification_context(test):
+    if test != "test":
+        raise ValueError("Invalid test value")
+    return {"foo": "bar"}
+
+
+def test_send_notification(notification_backend, notification_service, celery_app, celery_worker):
+    notification = create_notification()
+    notification_backend.notifications.append(notification)
+    notification_backend._store_notifications()
+
+    notification_service.send(notification)
+    assert len(notification_backend.notifications) == 1
+
+
+def test_send_notification_with_render_error(notification_backend, celery_app, celery_worker):
+    notification = create_notification()
+
+    renderer = FakeTemplateRendererWithException()
+    async_adapter = AsyncCeleryFakeEmailAdapter(
+        template_renderer=renderer, backend=notification_backend
+    )
+
+    notification_service = NotificationService(
+        [async_adapter],
+        notification_backend,
+    )
+
+    notification_backend.notifications.append(notification)
+    notification_backend._store_notifications()
+
+    with patch("vintasend.tasks.background_tasks.logger.exception") as mock_log_exception:
+        notification_service.send(notification)
+
+    mock_log_exception.assert_called_once()
+
+    assert len(async_adapter.sent_emails) == 0
+
+
+def test_backend_with_non_serializable_kwargs(renderer, celery_app, celery_worker):
+    notification = create_notification()
+    config = Config()
+    backend = FakeFileBackendWithNonSerializableKWArgs(
+        database_file_name="celery-adapter-tests-notifications.json",
+        config=config,
+    )
+    async_adapter = AsyncCeleryFakeEmailAdapterWithBackendWithNonSerializableKWArgs(
+        template_renderer=renderer, backend=backend, config=config
+    )
+
+    notification_service = NotificationService(
+        [async_adapter],
+        backend,
+    )
+
+    backend.notifications.append(notification)
+    backend._store_notifications()
+
+    notification_service.send(notification)
+
+    assert len(backend.notifications) == 1
+
+    backend.clear()