dotflow 0.12.0.dev3__tar.gz → 0.13.0.dev1__tar.gz

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dotflow
-Version: 0.12.0.dev3
+Version: 0.13.0.dev1
 Summary: 🎲 Dotflow turns an idea into flow!
 License: MIT License
          
@@ -37,6 +37,7 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: mongodb
 Requires-Dist: dotflow-mongodb ; extra == "mongodb"
 Requires-Dist: pydantic
+Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: typing-extensions
 Project-URL: Documentation, https://github.com/dotflow-io/dotflow/blob/master/README.md

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/__init__.py

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

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/abc/flow.py

@@ -34,7 +34,7 @@ class Flow(ABC):
         return self.queue
 
     @abstractmethod
-    def _internal_callback(self, task: Task) -> None:
+    def _flow_callback(self, task: Task) -> None:
         self.queue.append(task)
 
     @abstractmethod

dotflow-0.13.0.dev1/dotflow/abc/log.py

@@ -0,0 +1,17 @@
+"""Notify ABC"""
+
+from typing import Any
+
+from abc import ABC, abstractmethod
+
+
+class Log(ABC):
+    """Log"""
+
+    @abstractmethod
+    def info(self, task: Any) -> None:
+        """Info"""
+
+    @abstractmethod
+    def error(self, task: Any) -> None:
+        """Error"""

dotflow-0.13.0.dev1/dotflow/abc/notify.py

@@ -0,0 +1,13 @@
+"""Notify ABC"""
+
+from typing import Any
+
+from abc import ABC, abstractmethod
+
+
+class Notify(ABC):
+    """Notify"""
+
+    @abstractmethod
+    def send(self, task: Any) -> None:
+        """Send"""

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/action.py

@@ -1,11 +1,25 @@
 """Action module"""
 
+from time import sleep
+
+from concurrent.futures import ThreadPoolExecutor
 from typing import Callable, Dict
 from types import FunctionType
 
+from dotflow.core.exception import ExecutionWithClassError
 from dotflow.core.context import Context
 
 
+def is_execution_with_class_internal_error(error: Exception) -> bool:
+    message = str(error)
+    patterns = [
+        "initial_context",
+        "previous_context",
+        "missing 1 required positional argument: 'self'",
+    ]
+    return any(pattern in message for pattern in patterns)
+
+
 class Action(object):
     """
     Import:
@@ -39,14 +53,20 @@ class Action(object):
     """
 
     def __init__(
-            self,
-            func: Callable = None,
-            task: Callable = None,
-            retry: int = 1
+        self,
+        func: Callable = None,
+        task: Callable = None,
+        retry: int = 1,
+        timeout: int = 0,
+        retry_delay: int = 1,
+        backoff: bool = False,
     ) -> None:
         self.func = func
         self.task = task
         self.retry = retry
+        self.timeout = timeout
+        self.retry_delay = retry_delay
+        self.backoff = backoff
         self.params = []
 
     def __call__(self, *args, **kwargs):
@@ -59,15 +79,15 @@ class Action(object):
 
             if contexts:
                 return Context(
-                    storage=self._retry(*args, **contexts),
+                    storage=self._run_action(*args, **contexts),
                     task_id=task.task_id,
-                    workflow_id=task.workflow_id
+                    workflow_id=task.workflow_id,
                 )
 
             return Context(
-                storage=self._retry(*args),
+                storage=self._run_action(*args),
                 task_id=task.task_id,
-                workflow_id=task.workflow_id
+                workflow_id=task.workflow_id,
             )
 
         # No parameters
@@ -80,31 +100,41 @@ class Action(object):
 
             if contexts:
                 return Context(
-                    storage=self._retry(*_args, **contexts),
+                    storage=self._run_action(*_args, **contexts),
                     task_id=task.task_id,
-                    workflow_id=task.workflow_id
+                    workflow_id=task.workflow_id,
                 )
 
             return Context(
-                storage=self._retry(*_args),
+                storage=self._run_action(*_args),
                 task_id=task.task_id,
-                workflow_id=task.workflow_id
+                workflow_id=task.workflow_id,
             )
 
         return action
 
-    def _retry(self, *args, **kwargs):
-        attempt = 0
-        exception = Exception()
-
-        while self.retry > attempt:
+    def _run_action(self, *args, **kwargs):
+        for attempt in range(1, self.retry + 1):
             try:
+                if self.timeout:
+                    with ThreadPoolExecutor(max_workers=1) as executor:
+                        future = executor.submit(self.func, *args, **kwargs)
+                        return future.result(timeout=self.timeout)
+
                 return self.func(*args, **kwargs)
+
             except Exception as error:
-                exception = error
-                attempt += 1
+                last_exception = error
+
+                if is_execution_with_class_internal_error(error=last_exception):
+                    raise ExecutionWithClassError()
+
+                if attempt == self.retry:
+                    raise last_exception
 
-        raise exception
+                sleep(self.retry_delay)
+                if self.backoff:
+                    self.retry_delay *= 2
 
     def _set_params(self):
         if isinstance(self.func, FunctionType):
@@ -113,7 +143,9 @@ class Action(object):
         if type(self.func) is type:
             if hasattr(self.func, "__init__"):
                 if hasattr(self.func.__init__, "__code__"):
-                    self.params = [param for param in self.func.__init__.__code__.co_varnames]
+                    self.params = [
+                        param for param in self.func.__init__.__code__.co_varnames
+                    ]
 
     def _get_context(self, kwargs: Dict):
         context = {}

dotflow-0.13.0.dev1/dotflow/core/config.py

@@ -0,0 +1,54 @@
+"""Config module"""
+
+from typing import Optional
+
+from dotflow.abc.log import Log
+from dotflow.abc.storage import Storage
+from dotflow.abc.notify import Notify
+
+from dotflow.providers.log_default import LogDefault
+from dotflow.providers.storage_default import StorageDefault
+from dotflow.providers.notify_default import NotifyDefault
+
+
+class Config:
+    """
+    Import:
+        You can import the **Config** class with:
+
+            from dotflow import Config
+            from dotflow.providers import (
+                StorageDefault,
+                NotifyDefault,
+                LogDefault
+            )
+
+    Example:
+        `class` dotflow.core.config.Config
+
+            config = Config(
+                storage=StorageFile(path=".output"),
+                notify=NotifyDefault(),
+                log=LogDefault()
+            )
+
+    Args:
+        storage (Optional[Storage]): Type of the storage.
+        notify (Optional[Notify]): Type of the notify.
+        log (Optional[Log]): Type of the notify.
+
+    Attributes:
+        storage (Optional[Storage]):
+        notify (Optional[Notify]):
+        log (Optional[Log]):
+    """
+
+    def __init__(
+        self,
+        storage: Optional[Storage] = None,
+        notify: Optional[Notify] = None,
+        log: Optional[Log] = None,
+    ) -> None:
+        self.storage = storage if storage else StorageDefault()
+        self.notify = notify if notify else NotifyDefault()
+        self.log = log if log else LogDefault()

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/dotflow.py

@@ -2,6 +2,7 @@
 
 from uuid import uuid4
 from functools import partial
+from typing import Optional
 
 from dotflow.core.config import Config
 from dotflow.core.workflow import Manager
@@ -26,7 +27,7 @@ class DotFlow:
             workflow = DotFlow(config=config)
 
     Args:
-        config (Config): Configuration class.
+        config (Optional[Config]): Configuration class.
 
     Attributes:
         workflow_id (UUID):
@@ -38,9 +39,10 @@ class DotFlow:
 
     def __init__(
             self,
-            config: Config = Config()
+            config: Optional[Config] = None
     ) -> None:
         self.workflow_id = uuid4()
+        config = config if config else Config()
 
         self.task = TaskBuilder(
             config=config,

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/exception.py

@@ -63,3 +63,8 @@ class ModuleNotFound(Exception):
                 library=library
             )
         )
+
+
+class ExecutionWithClassError(Exception):
+    def __init__(self):
+        super(ExecutionWithClassError, self).__init__("Unknown")

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/execution.py

@@ -1,6 +1,7 @@
 """Execution module"""
 
 from uuid import UUID
+from datetime import datetime
 from typing import Callable, List, Tuple
 from inspect import getsourcelines
 from types import FunctionType
@@ -10,13 +11,13 @@ try:
 except ImportError:
     NoneType = type(None)
 
+from dotflow.core.exception import ExecutionWithClassError
 from dotflow.logging import logger
 from dotflow.core.action import Action
 from dotflow.core.context import Context
 from dotflow.core.task import Task
-from dotflow.core.types import TaskStatus
+from dotflow.core.types import TypeStatus
 
-from dotflow.core.decorators import time
 from dotflow.utils import basic_callback
 
 
@@ -46,14 +47,14 @@ class Execution:
         task: Task,
         workflow_id: UUID,
         previous_context: Context = None,
-        _internal_callback: Callable = basic_callback,
+        _flow_callback: Callable = basic_callback,
     ) -> None:
         self.task = task
-        self.task.status = TaskStatus.IN_PROGRESS
+        self.task.status = TypeStatus.IN_PROGRESS
         self.task.previous_context = previous_context
         self.task.workflow_id = workflow_id
 
-        self._excution(_internal_callback)
+        self._excution(_flow_callback)
 
     def _is_action(self, class_instance: Callable, func: Callable):
         try:
@@ -116,7 +117,10 @@ class Execution:
                 new_context.storage.append(subcontext)
                 previous_context = subcontext
 
-            except Exception:
+            except Exception as error:
+                if not isinstance(error, ExecutionWithClassError):
+                    raise error
+
                 subcontext = new_object(
                     class_instance,
                     initial_context=self.task.initial_context,
@@ -131,9 +135,9 @@ class Execution:
 
         return new_context
 
-    @time
-    def _excution(self, _internal_callback):
+    def _excution(self, _flow_callback):
         try:
+            start = datetime.now()
             current_context = self.task.step(
                 initial_context=self.task.initial_context,
                 previous_context=self.task.previous_context,
@@ -145,19 +149,20 @@ class Execution:
                     class_instance=current_context.storage
                 )
 
-            self.task.status = TaskStatus.COMPLETED
             self.task.current_context = current_context
+            self.task.duration = (datetime.now() - start).total_seconds()
+            self.task.status = TypeStatus.COMPLETED
 
         except AssertionError as err:
             raise err
 
         except Exception as err:
-            self.task.status = TaskStatus.FAILED
-            self.task.current_context = None
             self.task.error = err
+            self.task.current_context = None
+            self.task.status = TypeStatus.FAILED
 
         finally:
             self.task.callback(task=self.task)
-            _internal_callback(task=self.task)
+            _flow_callback(task=self.task)
 
         return self.task

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/task.py

@@ -5,9 +5,6 @@ import json
 from uuid import UUID
 from typing import Any, Callable, List
 
-from rich.console import Console  # type: ignore
-
-from dotflow.logging import logger
 from dotflow.core.config import Config
 from dotflow.core.action import Action
 from dotflow.core.context import Context
@@ -15,7 +12,7 @@ from dotflow.core.module import Module
 from dotflow.core.serializers.task import SerializerTask
 from dotflow.core.serializers.workflow import SerializerWorkflow
 from dotflow.core.exception import MissingActionDecorator, NotCallableObject
-from dotflow.core.types.status import TaskStatus
+from dotflow.core.types.status import TypeStatus
 from dotflow.utils import (
     basic_callback,
     traceback_error,
@@ -103,14 +100,14 @@ class Task(TaskInstance):
             config,
             group_name
         )
+        self.config = config
+        self.group_name = group_name
         self.task_id = task_id
         self.workflow_id = workflow_id
         self.step = step
         self.callback = callback
         self.initial_context = initial_context
-        self.status = TaskStatus.NOT_STARTED
-        self.config = config
-        self.group_name = group_name
+        self.status = TypeStatus.NOT_STARTED
 
     @property
     def step(self):
@@ -206,33 +203,20 @@ class Task(TaskInstance):
             task_error = TaskError(value)
             self._error = task_error
 
-            logger.error(
-                "ID %s - %s - %s \n %s",
-                self.workflow_id,
-                self.task_id,
-                self.status,
-                task_error.traceback,
-            )
-
-            console = Console()
-            console.print_exception(show_locals=True)
+            self.config.log.error(task=self)
 
     @property
     def status(self):
         if not self._status:
-            return TaskStatus.NOT_STARTED
+            return TypeStatus.NOT_STARTED
         return self._status
 
     @status.setter
-    def status(self, value: TaskStatus) -> None:
+    def status(self, value: TypeStatus) -> None:
         self._status = value
 
-        logger.info(
-            "ID %s - %s - %s",
-            self.workflow_id,
-            self.task_id,
-            self.status,
-        )
+        self.config.notify.send(task=self)
+        self.config.log.info(task=self)
 
     @property
     def config(self):

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/types/__init__.py

@@ -1,12 +1,12 @@
 """Types __init__ module."""
 
 from dotflow.core.types.execution import TypeExecution
-from dotflow.core.types.status import TaskStatus
+from dotflow.core.types.status import TypeStatus
 from dotflow.core.types.storage import TypeStorage
 
 
 __all__ = [
     "TypeExecution",
-    "TaskStatus",
+    "TypeStatus",
     "TypeStorage"
 ]

dotflow-0.13.0.dev1/dotflow/core/types/status.py

@@ -0,0 +1,31 @@
+"""Type TypeStatus mode module"""
+
+from typing_extensions import Annotated, Doc
+
+
+class TypeStatus:
+    """
+    Import:
+        You can import the **TypeStatus** class with:
+
+            from dotflow.core.types import TypeStatus
+    """
+
+    NOT_STARTED: Annotated[str, Doc("Status not started.")] = "Not started"
+    IN_PROGRESS: Annotated[str, Doc("Status in progress.")] = "In progress"
+    COMPLETED: Annotated[str, Doc("Status completed.")] = "Completed"
+    PAUSED: Annotated[str, Doc("Status paused.")] = "Paused"
+    RETRY: Annotated[str, Doc("Status retry.")] = "Retry"
+    FAILED: Annotated[str, Doc("Status failed.")] = "Failed"
+
+    @classmethod
+    def get_symbol(cls, value: str) -> str:
+        status = {
+           TypeStatus.NOT_STARTED: "⚪",
+           TypeStatus.IN_PROGRESS: "🔵",
+           TypeStatus.COMPLETED: "✅",
+           TypeStatus.PAUSED: "◼️",
+           TypeStatus.RETRY: "❗",
+           TypeStatus.FAILED: "❌"
+        }
+        return status.get(value)

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/dotflow/core/workflow.py

@@ -14,7 +14,7 @@ from dotflow.abc.flow import Flow
 from dotflow.core.context import Context
 from dotflow.core.execution import Execution
 from dotflow.core.exception import ExecutionModeNotExist
-from dotflow.core.types import TypeExecution, TaskStatus
+from dotflow.core.types import TypeExecution, TypeStatus
 from dotflow.core.task import Task
 from dotflow.utils import basic_callback
 
@@ -117,7 +117,7 @@ class Manager:
     def _callback_workflow(self, tasks: List[Task]):
         final_status = [task.status for task in tasks]
 
-        if TaskStatus.FAILED in final_status:
+        if TypeStatus.FAILED in final_status:
             self.failure(tasks=tasks)
         else:
             self.success(tasks=tasks)
@@ -161,7 +161,7 @@ class Sequential(Flow):
     def get_tasks(self) -> List[Task]:
         return self.queue
 
-    def _internal_callback(self, task: Task) -> None:
+    def _flow_callback(self, task: Task) -> None:
         self.queue.append(task)
 
     def run(self) -> None:
@@ -172,14 +172,14 @@ class Sequential(Flow):
                 task=task,
                 workflow_id=self.workflow_id,
                 previous_context=previous_context,
-                _internal_callback=self._internal_callback,
+                _flow_callback=self._flow_callback,
             )
 
             previous_context = task.config.storage.get(
                 key=task.config.storage.key(task=task)
             )
 
-            if not self.ignore and task.status == TaskStatus.FAILED:
+            if not self.ignore and task.status == TypeStatus.FAILED:
                 break
 
 
@@ -204,7 +204,7 @@ class SequentialGroup(Flow):
 
         return self.tasks
 
-    def _internal_callback(self, task: Task) -> None:
+    def _flow_callback(self, task: Task) -> None:
         current_task = {
             task.task_id: {
                 "current_context": task.current_context,
@@ -249,14 +249,14 @@ class SequentialGroup(Flow):
                 task=task,
                 workflow_id=self.workflow_id,
                 previous_context=previous_context,
-                _internal_callback=self._internal_callback,
+                _flow_callback=self._flow_callback,
             )
 
             previous_context = task.config.storage.get(
                 key=task.config.storage.key(task=task)
             )
 
-            if not self.ignore and task.status == TaskStatus.FAILED:
+            if not self.ignore and task.status == TypeStatus.FAILED:
                 break
 
 
@@ -269,7 +269,7 @@ class Background(Flow):
     def get_tasks(self) -> List[Task]:
         return self.tasks
 
-    def _internal_callback(self, task: Task) -> None:
+    def _flow_callback(self, task: Task) -> None:
         pass
 
     def run(self) -> None:
@@ -306,7 +306,7 @@ class Parallel(Flow):
 
         return self.tasks
 
-    def _internal_callback(self, task: Task) -> None:
+    def _flow_callback(self, task: Task) -> None:
         current_task = {
             task.task_id: {
                 "current_context": task.current_context,
@@ -324,7 +324,7 @@ class Parallel(Flow):
         for task in self.tasks:
             process = Process(
                 target=Execution,
-                args=(task, self.workflow_id, previous_context, self._internal_callback),
+                args=(task, self.workflow_id, previous_context, self._flow_callback),
             )
             process.start()
             processes.append(process)

dotflow-0.13.0.dev1/dotflow/notify.py

@@ -0,0 +1,6 @@
+"""Notify module"""
+
+from .providers.notify_telegram import NotifyTelegram
+from .providers.notify_default import NotifyDefault
+
+__all__ = ["NotifyTelegram", "NotifyDefault"]

dotflow-0.13.0.dev1/dotflow/providers/log_default.py

@@ -0,0 +1,30 @@
+"""Notify Default"""
+
+from typing import Any
+
+from rich.console import Console  # type: ignore
+
+from dotflow.abc.log import Log
+from dotflow.logging import logger
+
+
+class LogDefault(Log):
+
+    def info(self, task: Any) -> None:
+        logger.info(
+            "ID %s - %s - %s",
+            task.workflow_id,
+            task.task_id,
+            task.status,
+        )
+
+    def error(self, task: Any) -> None:
+        logger.error(
+            "ID %s - %s - %s \n %s",
+            task.workflow_id,
+            task.task_id,
+            task.status,
+            task.error.traceback,
+        )
+        console = Console()
+        console.print_exception(show_locals=True)

dotflow-0.13.0.dev1/dotflow/providers/notify_default.py

@@ -0,0 +1,11 @@
+"""Notify Default"""
+
+from typing import Any
+
+from dotflow.abc.notify import Notify
+
+
+class NotifyDefault(Notify):
+
+    def send(self, task: Any) -> None:
+        pass

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

@@ -0,0 +1,56 @@
+"""Notify Default"""
+
+from json import dumps
+from typing import Any, Optional
+
+from requests import post
+
+from dotflow.core.types.status import TypeStatus
+from dotflow.abc.notify import Notify
+from dotflow.logging import logger
+
+MESSAGE = "{symbol} {status}\n```json\n{task}```\n{workflow_id}-{task_id}"
+API_TELEGRAM = "https://api.telegram.org/bot{token}/sendMessage"
+
+
+class NotifyTelegram(Notify):
+
+    def __init__(
+        self,
+        token: str,
+        chat_id: int,
+        notification_type: Optional[TypeStatus] = None
+    ):
+        self.token = token
+        self.chat_id = chat_id
+        self.notification_type = notification_type
+
+    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=API_TELEGRAM.format(token=self.token),
+                    headers={"Content-Type": "application/json"},
+                    data=dumps(data),
+                    timeout=5
+                )
+                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 MESSAGE.format(
+            symbol=TypeStatus.get_symbol(task.status),
+            status=task.status,
+            workflow_id=task.workflow_id,
+            task_id=task.task_id,
+            task=task.result(),
+        )

dotflow-0.13.0.dev1/dotflow/providers.py

@@ -0,0 +1,15 @@
+"""Providers module"""
+
+from dotflow.providers.log_default import LogDefault
+from dotflow.providers.notify_default import NotifyDefault
+from dotflow.providers.notify_telegram import NotifyTelegram
+from dotflow.providers.storage_default import StorageDefault
+from dotflow.providers.storage_file import StorageFile
+
+__all__ = [
+    "LogDefault",
+    "NotifyDefault",
+    "NotifyTelegram",
+    "StorageDefault",
+    "StorageFile"
+]

dotflow-0.13.0.dev1/dotflow/types.py

@@ -0,0 +1,9 @@
+"""Types module"""
+
+from dotflow.core.types.status import TypeStatus
+from dotflow.core.types.storage import TypeStorage
+
+__all__ = [
+    "TypeStatus",
+    "TypeStorage"
+]

{dotflow-0.12.0.dev3 → dotflow-0.13.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.12.0.dev3"
+version = "0.13.0.dev1"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -11,7 +11,8 @@ requires-python = ">=3.9"
 dependencies = [
 	"rich",
   "pydantic",
-  "typing-extensions"
+  "typing-extensions",
+  "requests"
 ]
 classifiers = [
   'Development Status :: 4 - Beta',
@@ -35,7 +36,7 @@ mongodb = ["dotflow-mongodb"]
 
 [tool.poetry]
 name = "dotflow"
-version = "0.12.0.dev3"
+version = "0.13.0.dev1"
 description = "🎲 Dotflow turns an idea into flow!"
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"
@@ -63,6 +64,8 @@ python = ">=3.9.0"
 rich = "^13.9.4"
 pydantic = "^2.10.6"
 typing-extensions = "^4.12.2"
+python-dotenv = "^1.1.0"
+requests = "^2.32.3"
 
 [tool.poetry.group.dev.dependencies]
 build = "^1.2.2.post1"

dotflow-0.12.0.dev3/dotflow/core/config.py

@@ -1,28 +0,0 @@
-"""Config module"""
-
-from dotflow.abc.storage import Storage
-from dotflow.providers.storage_default import StorageDefault
-
-
-class Config:
-    """
-    Import:
-        You can import the **Config** class with:
-
-            from dotflow import Config
-            from dotflow.storage import StorageDefault
-
-    Example:
-        `class` dotflow.core.config.Config
-
-            config = Config(storage=StorageDefault)
-
-    Args:
-        storage (Storage): Type of the storage.
-
-    Attributes:
-        storage (Storage):
-    """
-
-    def __init__(self, storage: Storage = StorageDefault()) -> None:
-        self.storage = storage

dotflow-0.12.0.dev3/dotflow/core/types/status.py

@@ -1,19 +0,0 @@
-"""Type TaskStatus mode module"""
-
-from typing_extensions import Annotated, Doc
-
-
-class TaskStatus:
-    """
-    Import:
-        You can import the **TaskStatus** class with:
-
-            from dotflow.core.types import TaskStatus
-    """
-
-    NOT_STARTED: Annotated[str, Doc("Status not started.")] = "Not started"
-    IN_PROGRESS: Annotated[str, Doc("Status in progress.")] = "In progress"
-    COMPLETED: Annotated[str, Doc("Status completed.")] = "Completed"
-    PAUSED: Annotated[str, Doc("Status paused.")] = "Paused"
-    RETRY: Annotated[str, Doc("Status retry.")] = "Retry"
-    FAILED: Annotated[str, Doc("Status failed.")] = "Failed"