dotflow 0.14.1.dev1__tar.gz → 0.14.1.dev2__tar.gz

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotflow
-Version: 0.14.1.dev1
+Version: 0.14.1.dev2
 Summary: 🎲 Dotflow turns an idea into flow! Lightweight Python library for execution pipelines with retry, parallel, cron and async support.
 License: MIT License
          
@@ -648,7 +648,7 @@ Extend Dotflow by implementing the abstract base classes:
 | ABC | Methods | Purpose |
 |-----|---------|---------|
 | `Storage` | `post`, `get`, `key` | Custom storage backends |
-| `Notify` | `send` | Custom notification channels |
+| `Notify` | `hook_status_task` | Custom notification channels |
 | `Log` | `info`, `error` | Custom logging |
 | `Scheduler` | `start`, `stop` | Custom scheduling strategies |
 

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/README.md

@@ -587,7 +587,7 @@ Extend Dotflow by implementing the abstract base classes:
 | ABC | Methods | Purpose |
 |-----|---------|---------|
 | `Storage` | `post`, `get`, `key` | Custom storage backends |
-| `Notify` | `send` | Custom notification channels |
+| `Notify` | `hook_status_task` | Custom notification channels |
 | `Log` | `info`, `error` | Custom logging |
 | `Scheduler` | `start`, `stop` | Custom scheduling strategies |
 

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/dotflow/__init__.py

@@ -1,6 +1,6 @@
 """Dotflow __init__ module."""
 
-__version__ = "0.14.1.dev1"
+__version__ = "0.14.1.dev2"
 __description__ = "🎲 Dotflow turns an idea into flow!"
 
 from .core.action import Action as action

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/dotflow/abc/notify.py

@@ -8,5 +8,5 @@ class Notify(ABC):
     """Notify"""
 
     @abstractmethod
-    def send(self, task: Any) -> None:
-        """Send"""
+    def hook_status_task(self, task: Any) -> None:
+        """Hook called when a task status changes."""

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/dotflow/core/task.py

@@ -248,7 +248,7 @@ class Task(TaskInstance):
     def status(self, value: TypeStatus) -> None:
         self._status = value
 
-        self.config.notify.send(task=self)
+        self.config.notify.hook_status_task(task=self)
         self.config.log.info(task=self)
 
     @property

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/dotflow/providers/__init__.py

@@ -2,6 +2,7 @@
 
 from dotflow.providers.log_default import LogDefault
 from dotflow.providers.notify_default import NotifyDefault
+from dotflow.providers.notify_discord import NotifyDiscord
 from dotflow.providers.notify_telegram import NotifyTelegram
 from dotflow.providers.scheduler_default import SchedulerDefault
 from dotflow.providers.storage_default import StorageDefault
@@ -10,6 +11,7 @@ from dotflow.providers.storage_file import StorageFile
 __all__ = [
     "LogDefault",
     "NotifyDefault",
+    "NotifyDiscord",
     "NotifyTelegram",
     "SchedulerCron",
     "SchedulerDefault",

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/dotflow/providers/notify_default.py

@@ -6,5 +6,5 @@ from dotflow.abc.notify import Notify
 
 
 class NotifyDefault(Notify):
-    def send(self, task: Any) -> None:
+    def hook_status_task(self, task: Any) -> None:
         pass

dotflow-0.14.1.dev2/dotflow/providers/notify_discord.py

@@ -0,0 +1,112 @@
+"""Notify Discord"""
+
+from __future__ import annotations
+
+from json import dumps
+from typing import Any
+
+from requests import post
+
+from dotflow.abc.notify import Notify
+from dotflow.core.types.status import TypeStatus
+from dotflow.logging import logger
+
+
+class NotifyDiscord(Notify):
+    """
+    Import:
+        You can import the **NotifyDiscord** class with:
+
+            from dotflow.providers import NotifyDiscord
+
+    Example:
+        `class` dotflow.providers.notify_discord.NotifyDiscord
+
+            from dotflow import Config, DotFlow
+            from dotflow.providers import NotifyDiscord
+            from dotflow.core.types.status import TypeStatus
+
+            config = Config(
+                notify=NotifyDiscord(
+                    webhook_url="https://discord.com/api/webhooks/...",
+                    notification_type=TypeStatus.FAILED,
+                )
+            )
+
+            workflow = DotFlow(config=config)
+
+    Args:
+        webhook_url (str): Discord webhook URL.
+
+        notification_type (Optional[TypeStatus]): Filter notifications
+            by task status. If None, all statuses are notified.
+
+        show_result (bool): Include task result in the notification.
+            Defaults to False.
+
+        timeout (float): Request timeout in seconds.
+    """
+
+    COLORS = {
+        TypeStatus.COMPLETED: 0x4CAF50,
+        TypeStatus.FAILED: 0xF44336,
+        TypeStatus.RETRY: 0xFF9800,
+        TypeStatus.IN_PROGRESS: 0x2196F3,
+        TypeStatus.NOT_STARTED: 0x9E9E9E,
+        TypeStatus.PAUSED: 0x607D8B,
+    }
+
+    def __init__(
+        self,
+        webhook_url: str,
+        notification_type: TypeStatus | None = None,
+        show_result: bool = False,
+        timeout: float = 1.5,
+    ):
+        self.webhook_url = webhook_url
+        self.notification_type = notification_type
+        self.show_result = show_result
+        self.timeout = timeout
+
+    def hook_status_task(self, task: Any) -> None:
+        if self.notification_type and self.notification_type != task.status:
+            return
+
+        try:
+            response = post(
+                url=self.webhook_url,
+                headers={"Content-Type": "application/json"},
+                data=dumps({"embeds": [self._build_embed(task)]}),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except Exception as error:
+            logger.error(
+                "Internal problem sending notification on Discord: %s",
+                str(error),
+            )
+
+    def _build_embed(self, task: Any) -> dict:
+        embed = {
+            "title": f"{TypeStatus.get_symbol(task.status)} {task.status}",
+            "color": self.COLORS.get(task.status, 0x9E9E9E),
+            "description": f"`{task.workflow_id}` — Task {task.task_id}",
+            "fields": [],
+        }
+
+        if self.show_result:
+            embed["fields"].append(
+                {
+                    "name": "Result",
+                    "value": f"```json\n{task.result(max=1024)}```",
+                }
+            )
+
+        if task.status == TypeStatus.FAILED and task.errors:
+            last_error = task.errors[-1]
+            error_value = f"`{last_error.exception}`: {last_error.message}"
+            embed["fields"].append(
+                {"name": "Error", "value": error_value[:1024]}
+            )
+
+        return embed

dotflow-0.14.1.dev2/dotflow/providers/notify_telegram.py

@@ -0,0 +1,109 @@
+"""Notify Telegram"""
+
+from __future__ import annotations
+
+from json import dumps
+from typing import Any
+
+from requests import post
+
+from dotflow.abc.notify import Notify
+from dotflow.core.types.status import TypeStatus
+from dotflow.logging import logger
+
+
+class NotifyTelegram(Notify):
+    """
+    Import:
+        You can import the **NotifyTelegram** class with:
+
+            from dotflow.providers import NotifyTelegram
+
+    Example:
+        `class` dotflow.providers.notify_telegram.NotifyTelegram
+
+            from dotflow import Config, DotFlow
+            from dotflow.providers import NotifyTelegram
+            from dotflow.core.types.status import TypeStatus
+
+            config = Config(
+                notify=NotifyTelegram(
+                    token="YOUR_BOT_TOKEN",
+                    chat_id=123456789,
+                    notification_type=TypeStatus.FAILED,
+                )
+            )
+
+            workflow = DotFlow(config=config)
+
+    Args:
+        token (str): Telegram bot token from BotFather.
+
+        chat_id (int): Telegram chat ID to send messages to.
+
+        notification_type (Optional[TypeStatus]): Filter notifications
+            by task status. If None, all statuses are notified.
+
+        show_result (bool): Include task result in the notification.
+            Defaults to False.
+
+        timeout (float): Request timeout in seconds.
+    """
+
+    API_URL = "https://api.telegram.org/bot{token}/sendMessage"
+
+    def __init__(
+        self,
+        token: str,
+        chat_id: int,
+        notification_type: TypeStatus | None = None,
+        show_result: bool = False,
+        timeout: float = 1.5,
+    ):
+        self.token = token
+        self.chat_id = chat_id
+        self.notification_type = notification_type
+        self.show_result = show_result
+        self.timeout = timeout
+
+    def hook_status_task(self, task: Any) -> None:
+        if self.notification_type and self.notification_type != task.status:
+            return
+
+        try:
+            response = post(
+                url=self.API_URL.format(token=self.token),
+                headers={"Content-Type": "application/json"},
+                data=dumps(
+                    {
+                        "chat_id": self.chat_id,
+                        "text": self._build_message(task),
+                        "parse_mode": "markdown",
+                    }
+                ),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except Exception as error:
+            logger.error(
+                "Internal problem sending notification on Telegram: %s",
+                str(error),
+            )
+
+    def _build_message(self, task: Any) -> str:
+        symbol = TypeStatus.get_symbol(task.status)
+        header = f"{symbol} {task.status}"
+        footer = f"`{task.workflow_id}` — Task {task.task_id}"
+
+        parts = [header]
+
+        if self.show_result:
+            parts.append(f"```json\n{task.result(max=4000)}```")
+
+        if task.status == TypeStatus.FAILED and task.errors:
+            last_error = task.errors[-1]
+            parts.append(f"`{last_error.exception}`: {last_error.message}")
+
+        parts.append(footer)
+
+        return "\n".join(parts)

{dotflow-0.14.1.dev1 → dotflow-0.14.1.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.14.1.dev1"
+version = "0.14.1.dev2"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -60,7 +60,7 @@ scheduler = ["croniter"]
 
 [tool.poetry]
 name = "dotflow"
-version = "0.14.1.dev1"
+version = "0.14.1.dev2"
 description = "🎲 Dotflow turns an idea into flow! Lightweight Python library for execution pipelines with retry, parallel, cron and async support."
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"

dotflow-0.14.1.dev1/dotflow/providers/notify_telegram.py

@@ -1,59 +0,0 @@
-"""Notify Default"""
-
-from __future__ import annotations
-
-from json import dumps
-from typing import Any
-
-from requests import post
-
-from dotflow.abc.notify import Notify
-from dotflow.core.types.status import TypeStatus
-from dotflow.logging import logger
-
-
-class NotifyTelegram(Notify):
-    MESSAGE = "{symbol} {status}\n```json\n{task}```\n{workflow_id}-{task_id}"
-    API_TELEGRAM = "https://api.telegram.org/bot{token}/sendMessage"
-
-    def __init__(
-        self,
-        token: str,
-        chat_id: int,
-        notification_type: TypeStatus | None = None,
-        timeout: int = 1.5,
-    ):
-        self.token = token
-        self.chat_id = chat_id
-        self.notification_type = notification_type
-        self.timeout = timeout
-
-    def send(self, task: Any) -> None:
-        if not self.notification_type or self.notification_type == task.status:
-            data = {
-                "chat_id": self.chat_id,
-                "text": self._get_text(task=task),
-                "parse_mode": "markdown",
-            }
-            try:
-                response = post(
-                    url=self.API_TELEGRAM.format(token=self.token),
-                    headers={"Content-Type": "application/json"},
-                    data=dumps(data),
-                    timeout=self.timeout,
-                )
-                response.raise_for_status()
-            except Exception as error:
-                logger.error(
-                    "Internal problem sending notification on Telegram: %s",
-                    str(error),
-                )
-
-    def _get_text(self, task: Any) -> str:
-        return self.MESSAGE.format(
-            symbol=TypeStatus.get_symbol(task.status),
-            status=task.status,
-            workflow_id=task.workflow_id,
-            task_id=task.task_id,
-            task=task.result(max=4000),
-        )