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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotflow
-Version: 0.14.0.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
          
@@ -43,12 +43,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: aws
 Provides-Extra: gcp
-Provides-Extra: mongodb
 Provides-Extra: scheduler
 Requires-Dist: boto3 ; extra == "aws"
 Requires-Dist: cookiecutter (>=2.0)
 Requires-Dist: croniter ; extra == "scheduler"
-Requires-Dist: dotflow-mongodb ; extra == "mongodb"
 Requires-Dist: google-cloud-storage ; extra == "gcp"
 Requires-Dist: pydantic
 Requires-Dist: requests
@@ -172,7 +170,7 @@ workflow.start()
 
 ### Execution Modes
 
-> [Process Mode docs](https://dotflow-io.github.io/dotflow/nav/learn/process-mode-sequential/)
+> [Process Mode docs](https://dotflow-io.github.io/dotflow/nav/concepts/process-mode-sequential/)
 
 Dotflow supports 4 execution strategies out of the box:
 
@@ -531,6 +529,8 @@ workflow.start()
 
 ### Scheduler / Cron
 
+> [Cron scheduler docs](https://dotflow-io.github.io/dotflow/nav/tutorial/scheduler-cron/) | [Default scheduler](https://dotflow-io.github.io/dotflow/nav/tutorial/scheduler-default/) | [Cron overlap (concepts)](https://dotflow-io.github.io/dotflow/nav/concepts/concept-cron-overlap/)
+
 Schedule workflows to run automatically using cron expressions.
 
 ```bash
@@ -578,7 +578,7 @@ The scheduler handles graceful shutdown via `SIGINT`/`SIGTERM` signals automatic
 
 ### CLI
 
-> [CLI docs](https://dotflow-io.github.io/dotflow/nav/learn/cli/simple-start/)
+> [CLI docs](https://dotflow-io.github.io/dotflow/nav/how-to/cli/simple-start/)
 
 Run workflows directly from the command line:
 
@@ -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.0.dev1 → dotflow-0.14.1.dev2}/README.md

@@ -109,7 +109,7 @@ workflow.start()
 
 ### Execution Modes
 
-> [Process Mode docs](https://dotflow-io.github.io/dotflow/nav/learn/process-mode-sequential/)
+> [Process Mode docs](https://dotflow-io.github.io/dotflow/nav/concepts/process-mode-sequential/)
 
 Dotflow supports 4 execution strategies out of the box:
 
@@ -468,6 +468,8 @@ workflow.start()
 
 ### Scheduler / Cron
 
+> [Cron scheduler docs](https://dotflow-io.github.io/dotflow/nav/tutorial/scheduler-cron/) | [Default scheduler](https://dotflow-io.github.io/dotflow/nav/tutorial/scheduler-default/) | [Cron overlap (concepts)](https://dotflow-io.github.io/dotflow/nav/concepts/concept-cron-overlap/)
+
 Schedule workflows to run automatically using cron expressions.
 
 ```bash
@@ -515,7 +517,7 @@ The scheduler handles graceful shutdown via `SIGINT`/`SIGTERM` signals automatic
 
 ### CLI
 
-> [CLI docs](https://dotflow-io.github.io/dotflow/nav/learn/cli/simple-start/)
+> [CLI docs](https://dotflow-io.github.io/dotflow/nav/how-to/cli/simple-start/)
 
 Run workflows directly from the command line:
 
@@ -585,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.0.dev1 → dotflow-0.14.1.dev2}/dotflow/__init__.py

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

{dotflow-0.14.0.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.0.dev1 → dotflow-0.14.1.dev2}/dotflow/core/action.py

@@ -144,7 +144,8 @@ class Action:
         for attempt in range(1, self.retry + 1):
             try:
                 if self.timeout:
-                    with ThreadPoolExecutor(max_workers=1) as executor:
+                    executor = ThreadPoolExecutor(max_workers=1)
+                    try:
                         future = executor.submit(
                             self._call_func,
                             is_async,
@@ -152,11 +153,23 @@ class Action:
                             **kwargs,
                         )
                         result = future.result(timeout=self.timeout)
+                    except TimeoutError:
+                        future.cancel()
+                        executor.shutdown(wait=False, cancel_futures=True)
+                        raise
+                    except Exception:
+                        executor.shutdown(wait=False)
+                        raise
+                    else:
+                        executor.shutdown(wait=False)
                 else:
                     result = self._call_func(is_async, *args, **kwargs)
 
                 return result
 
+            except TimeoutError:
+                raise
+
             except Exception as error:
                 last_exception = error
 
@@ -166,7 +179,7 @@ class Action:
                     raise ExecutionWithClassError() from None
 
                 if attempt == self.retry:
-                    raise last_exception from last_exception
+                    raise last_exception from None
 
                 if task is not None:
                     task.retry_count += 1
@@ -199,14 +212,20 @@ class Action:
 
     def _set_params(self):
         if isinstance(self.func, FunctionType):
-            self.params = list(self.func.__code__.co_varnames)
+            code = self.func.__code__
+            self.params = list(
+                code.co_varnames[: code.co_argcount + code.co_kwonlyargcount]
+            )
 
         if (
             type(self.func) is type
             and hasattr(self.func, "__init__")
             and hasattr(self.func.__init__, "__code__")
         ):
-            self.params = list(self.func.__init__.__code__.co_varnames)
+            code = self.func.__init__.__code__
+            self.params = list(
+                code.co_varnames[: code.co_argcount + code.co_kwonlyargcount]
+            )
 
     def _get_context(self, kwargs: dict):
         context = {}

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

@@ -61,17 +61,19 @@ class Config:
 
     def __init__(
         self,
-        storage: Storage | None = StorageDefault(),
-        notify: Notify | None = NotifyDefault(),
-        log: Log | None = LogDefault(),
-        api: Api | None = ApiDefault(),
-        scheduler: Scheduler | None = SchedulerDefault(),
+        storage: Storage | None = None,
+        notify: Notify | None = None,
+        log: Log | None = None,
+        api: Api | None = None,
+        scheduler: Scheduler | None = None,
     ) -> None:
-        self.storage = storage
-        self.notify = notify
-        self.log = log
-        self.api = api
-        self.scheduler = scheduler
+        self.storage = storage if storage is not None else StorageDefault()
+        self.notify = notify if notify is not None else NotifyDefault()
+        self.log = log if log is not None else LogDefault()
+        self.api = api if api is not None else ApiDefault()
+        self.scheduler = (
+            scheduler if scheduler is not None else SchedulerDefault()
+        )
 
         self._validate()
 

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

@@ -71,15 +71,19 @@ class Context(ContextInstance):
         if isinstance(value, int):
             self._task_id = value
 
-        if not self.task_id:
-            self._task_id = value
-
     @property
     def workflow_id(self):
         return self._workflow_id
 
     @workflow_id.setter
     def workflow_id(self, value: UUID):
+        if isinstance(value, str):
+            try:
+                value = UUID(value)
+            except ValueError as err:
+                raise ValueError(
+                    f"Invalid workflow_id: '{value}' is not a valid UUID format."
+                ) from err
         if isinstance(value, UUID):
             self._workflow_id = value
 

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

@@ -1,5 +1,6 @@
 """Execution module"""
 
+import re
 from collections.abc import Callable
 from datetime import datetime
 from inspect import getsourcelines
@@ -59,7 +60,7 @@ class Execution:
             return (
                 callable(getattr(class_instance, func))
                 and getattr(class_instance, func).__module__
-                is Action.__module__
+                == Action.__module__
                 and not func.startswith("__")
             )
         except AttributeError:
@@ -74,9 +75,13 @@ class Execution:
             inside_code = getsourcelines(class_instance.__class__)[0]
 
             for callable_name in callable_list:
+                pattern = re.compile(
+                    rf"\bdef\s+{re.escape(callable_name)}\s*\("
+                )
                 for index, code in enumerate(inside_code):
-                    if code.find(f"def {callable_name}") != -1:
+                    if pattern.search(code):
                         ordered_list.append((index, callable_name))
+                        break
 
             ordered_list.sort()
             return ordered_list

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

@@ -19,7 +19,7 @@ class Module:
         spec = file_location(value, cls._get_path(value))
         module = module_from_spec(spec)
 
-        sys.modules[module] = module
+        sys.modules[module.__name__] = module
         spec.loader.exec_module(module)
 
         if hasattr(module, cls._get_name(value)):

{dotflow-0.14.0.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.0.dev1 → dotflow-0.14.1.dev2}/dotflow/core/workflow.py

@@ -16,7 +16,18 @@ from dotflow.core.task import Task, TaskError
 from dotflow.core.types import TypeExecution, TypeStatus
 from dotflow.utils import basic_callback
 
-_mp = get_context("fork") if sys.platform != "win32" else get_context("spawn")
+if sys.platform == "win32":
+    _mp = get_context("spawn")
+else:
+    import multiprocessing
+
+    if sys.platform == "darwin" and hasattr(
+        multiprocessing, "set_forkserver_preload"
+    ):
+        import os
+
+        os.environ.setdefault("OBJC_DISABLE_INITIALIZE_FORK_SAFETY", "YES")
+    _mp = get_context("fork")
 
 
 def grouper(tasks: list[Task]) -> dict[str, list[Task]]:
@@ -107,20 +118,27 @@ class Manager:
         execution = None
         groups = grouper(tasks=tasks)
 
-        try:
-            execution = getattr(self, mode)
-        except AttributeError as err:
-            raise ExecutionModeNotExist() from err
+        VALID_MODES = {
+            "sequential",
+            "sequential_group",
+            "background",
+            "parallel",
+        }
+        if mode not in VALID_MODES:
+            raise ExecutionModeNotExist()
+
+        execution = getattr(self, mode)
 
         self.tasks = execution(
             tasks=tasks,
-            workflow_id=workflow_id,
+            workflow_id=self.workflow_id,
             ignore=keep_going,
             groups=groups,
             resume=resume,
         )
 
-        self._callback_workflow(tasks=self.tasks)
+        if mode != TypeExecution.BACKGROUND:
+            self._callback_workflow(tasks=self.tasks)
 
     def _callback_workflow(self, tasks: list[Task]):
         final_status = [task.status for task in tasks]
@@ -144,6 +162,7 @@ class Manager:
 
     def background(self, **kwargs) -> list[Task]:
         process = Background(**kwargs)
+        self.thread = process.thread
         return process.get_tasks()
 
     def parallel(self, **kwargs) -> list[Task]:
@@ -302,12 +321,14 @@ class Background(Flow):
 
     def setup_queue(self) -> None:
         self.queue = []
+        self._lock = threading.Lock()
 
     def get_tasks(self) -> list[Task]:
-        return self.queue
+        return self.tasks
 
     def _flow_callback(self, task: Task) -> None:
-        self.queue.append(task)
+        with self._lock:
+            self.queue.append(task)
 
     def _has_checkpoint(self, task: Task) -> bool:
         if not self.resume:
@@ -348,9 +369,10 @@ class Background(Flow):
                 break
 
     def run(self) -> None:
-        thread = threading.Thread(target=self._run_sequential)
-        thread.start()
-        thread.join()
+        self.thread = threading.Thread(
+            target=self._run_sequential, daemon=True
+        )
+        self.thread.start()
 
 
 class Parallel(Flow):

{dotflow-0.14.0.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.0.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.0.dev1 → dotflow-0.14.1.dev2}/dotflow/providers/scheduler_cron.py

@@ -92,6 +92,9 @@ class SchedulerCron(Scheduler):
         self._lock = threading.Lock()
         self._queue_count = 0
         self._parallel_semaphore = threading.Semaphore(10)
+        self._threads: list[threading.Thread] = []
+        self._prev_sigint = None
+        self._prev_sigterm = None
 
     def start(self, workflow: Callable, **kwargs) -> None:
         """Start the scheduler loop. Blocks the main thread.
@@ -123,9 +126,18 @@ class SchedulerCron(Scheduler):
 
             self._dispatch(workflow=workflow, **kwargs)
 
-    def stop(self) -> None:
-        """Stop the scheduler loop gracefully."""
+    def stop(self, timeout: float | None = None) -> None:
+        """Stop the scheduler loop and wait for in-flight threads.
+
+        Args:
+            timeout: Max seconds to wait for each thread. None = wait forever.
+        """
         self.running = False
+        self._restore_signals()
+        with self._lock:
+            threads, self._threads = self._threads, []
+        for thread in threads:
+            thread.join(timeout=timeout)
 
     def _dispatch(self, workflow: Callable, **kwargs) -> None:
         if self.overlap == TypeOverlap.SKIP:
@@ -140,6 +152,11 @@ class SchedulerCron(Scheduler):
                 self.overlap,
             )
 
+    def _track_thread(self, thread: threading.Thread) -> None:
+        with self._lock:
+            self._threads = [t for t in self._threads if t.is_alive()]
+            self._threads.append(thread)
+
     def _dispatch_skip(self, workflow: Callable, **kwargs) -> None:
         with self._lock:
             if self._executing:
@@ -151,6 +168,7 @@ class SchedulerCron(Scheduler):
             args=(workflow,),
             kwargs=kwargs,
         )
+        self._track_thread(thread)
         thread.start()
 
     def _dispatch_queue(self, workflow: Callable, **kwargs) -> None:
@@ -166,6 +184,7 @@ class SchedulerCron(Scheduler):
             args=(workflow,),
             kwargs=kwargs,
         )
+        self._track_thread(thread)
         thread.start()
 
     def _dispatch_parallel(self, workflow: Callable, **kwargs) -> None:
@@ -177,6 +196,7 @@ class SchedulerCron(Scheduler):
             args=(workflow,),
             kwargs=kwargs,
         )
+        self._track_thread(thread)
         thread.start()
 
     def _execute_parallel(self, workflow: Callable, **kwargs) -> None:
@@ -204,21 +224,35 @@ class SchedulerCron(Scheduler):
         finally:
             with self._lock:
                 if self._queue_count > 0:
-                    self._queue_count -= 1
-                    thread = threading.Thread(
+                    self._queue_count = 0
+                    next_thread = threading.Thread(
                         target=self._execute_queued,
                         args=(workflow,),
                         kwargs=kwargs,
                     )
-                    thread.start()
                 else:
                     self._executing = False
+                    next_thread = None
+
+            if next_thread is not None:
+                self._track_thread(next_thread)
+                next_thread.start()
 
     def _register_signals(self) -> None:
         if threading.current_thread() is not threading.main_thread():
             return
-        signal.signal(signal.SIGINT, self._handle_signal)
-        signal.signal(signal.SIGTERM, self._handle_signal)
+        self._prev_sigint = signal.signal(signal.SIGINT, self._handle_signal)
+        self._prev_sigterm = signal.signal(signal.SIGTERM, self._handle_signal)
+
+    def _restore_signals(self) -> None:
+        if threading.current_thread() is not threading.main_thread():
+            return
+        if self._prev_sigint is not None:
+            signal.signal(signal.SIGINT, self._prev_sigint)
+            self._prev_sigint = None
+        if self._prev_sigterm is not None:
+            signal.signal(signal.SIGTERM, self._prev_sigterm)
+            self._prev_sigterm = None
 
     def _handle_signal(self, signum, frame) -> None:
         self.stop()

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

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.14.0.dev1"
+version = "0.14.1.dev2"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -54,14 +54,13 @@ Documentation = "https://dotflow-io.github.io/dotflow/"
 Changelog = "https://dotflow-io.github.io/dotflow/nav/development/release-notes/"
 
 [project.optional-dependencies]
-mongodb = ["dotflow-mongodb"]
 aws = ["boto3"]
 gcp = ["google-cloud-storage"]
 scheduler = ["croniter"]
 
 [tool.poetry]
 name = "dotflow"
-version = "0.14.0.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"
@@ -116,7 +115,7 @@ requests = "^2.32.4"
 build = "^1.2.2.post1"
 pytest = "^8.3.4"
 flake8 = "^7.1.1"
-tox = "^4.23.2"
+tox = "^4.26.0"
 pytest-cov = "^6.0.0"
 pylint = "^3.3.4"
 pyzmq = "^26.2.1"
@@ -138,6 +137,7 @@ mkdocs-simple-blog = "0.2.0"
 mkdocs-material = "^9.6.13"
 markdown-include-variants = "^0.0.4"
 mkdocs-static-i18n = "^1.3.0"
+mkdocs-redirects = "^1.2.2"
 mdx-include = "^1.4.2"
 griffe = "<1.14"
 

dotflow-0.14.0.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),
-        )