dotflow 0.8.2.dev2__py3-none-any.whl → 0.9.0.dev2__py3-none-any.whl

dotflow/__init__.py

@@ -1,6 +1,6 @@
 """Dotflow __init__ module."""
 
-__version__ = "0.8.2.dev2"
+__version__ = "0.9.0.dev2"
 __description__ = "🎲 Dotflow turns an idea into flow!"
 
 from .core.config import Config

dotflow/cli/command.py

@@ -1,10 +1,14 @@
 """Command module"""
 
+from abc import ABC, abstractmethod
 
-class Command:
+
+class Command(ABC):
 
     def __init__(self, **kwargs):
         self.params = kwargs.get("arguments")
+        self.setup()
 
-        if hasattr(self.params, "option"):
-            getattr(self, self.params.option)()
+    @abstractmethod
+    def setup(self):
+        pass

dotflow/cli/commands/__init__.py

@@ -1,12 +1,12 @@
 """Commands __init__ module."""
 
 from dotflow.cli.commands.init import InitCommand
-from dotflow.cli.commands.server import ServerCommand
+from dotflow.cli.commands.log import LogCommand
 from dotflow.cli.commands.start import StartCommand
 
 
 __all__ = [
     "InitCommand",
-    "ServerCommand",
+    "LogCommand",
     "StartCommand"
 ]

dotflow/cli/commands/init.py

@@ -1,16 +1,19 @@
 """Command init module"""
 
-from os import system, path
+from os import system
 
+from rich import print  # type: ignore
+
+from dotflow.settings import Settings as settings
 from dotflow.cli.command import Command
 
 
 class InitCommand(Command):
 
-    def __init__(self, **kwargs):
-        self.params = kwargs.get("arguments")
-        self.init()
-
-    def init(self):
-        if path.isfile(".gitignore"):
+    def setup(self):
+        if settings.GITIGNORE.exists():
             system("echo '\n\n# Dotflow\n.output' >> .gitignore")
+            print(
+                settings.INFO_ALERT,
+                f"Installation complete! The ({settings.GITIGNORE.resolve()}) file has been modified."
+            )

dotflow/cli/commands/log.py

@@ -0,0 +1,21 @@
+"""Command log module"""
+
+from rich import print  # type: ignore
+
+from dotflow.utils import read_file
+from dotflow.settings import Settings as settings
+from dotflow.cli.command import Command
+
+
+class LogCommand(Command):
+
+    def setup(self):
+        if settings.LOG_PATH.exists():
+            print(read_file(path=settings.LOG_PATH))
+
+            print(
+                settings.INFO_ALERT,
+                f"To access all logs, open the file ({settings.LOG_PATH.resolve()})."
+            )
+        else:
+            print(settings.WARNING_ALERT, "Log file not found.")

dotflow/cli/commands/start.py

@@ -9,11 +9,7 @@ from dotflow.cli.command import Command
 
 class StartCommand(Command):
 
-    def __init__(self, **kwargs):
-        self.params = kwargs.get("arguments")
-        self.start()
-
-    def start(self):
+    def setup(self):
         workflow = DotFlow(
             config=Config(
                 path=self.params.path,

dotflow/cli/setup.py

@@ -3,7 +3,7 @@
 from rich import print  # type: ignore
 
 from dotflow import __version__, __description__
-from dotflow.log import logger
+from dotflow.logging import logger
 from dotflow.settings import Settings as settings
 from dotflow.utils.basic_functions import basic_callback
 from dotflow.core.types.execution import TypeExecution
@@ -13,7 +13,11 @@ from dotflow.core.exception import (
     ModuleNotFound,
     MESSAGE_UNKNOWN_ERROR,
 )
-from dotflow.cli.commands import InitCommand, ServerCommand, StartCommand
+from dotflow.cli.commands import (
+    InitCommand,
+    LogCommand,
+    StartCommand
+)
 
 
 class Command:
@@ -32,16 +36,10 @@ class Command:
         )
 
         self.setup_init()
+        self.setup_logs()
         self.setup_start()
         self.command()
 
-    def setup_server(self):
-        self.cmd_server = self.subparsers.add_parser("server", help="Server")
-        self.cmd_server = self.cmd_server.add_argument_group(
-            "Usage: dotflow server [OPTIONS]"
-        )
-        self.cmd_server.set_defaults(exec=ServerCommand)
-
     def setup_init(self):
         self.cmd_init = self.subparsers.add_parser("init", help="Init")
         self.cmd_init = self.cmd_init.add_argument_group(
@@ -61,7 +59,7 @@ class Command:
         self.cmd_start.add_argument(
             "-o", "--output-context", default=False, action="store_true"
         )
-        self.cmd_start.add_argument("-p", "--path", default=settings.INITIAL_PATH)
+        self.cmd_start.add_argument("-p", "--path", default=settings.START_PATH)
         self.cmd_start.add_argument(
             "-m",
             "--mode",
@@ -71,10 +69,14 @@ class Command:
 
         self.cmd_start.set_defaults(exec=StartCommand)
 
+    def setup_logs(self):
+        self.cmd_logs = self.subparsers.add_parser("logs", help="Logs")
+        self.cmd_logs = self.cmd_logs.add_argument_group(
+            "Usage: dotflow log [OPTIONS]"
+        )
+        self.cmd_logs.set_defaults(exec=LogCommand)
+
     def command(self):
-        message_icon = ":game_die:"
-        message_error = "[bold red]Error:[/bold red]"
-    
         try:
             arguments = self.parser.parse_args()
             if hasattr(arguments, "exec"):
@@ -82,14 +84,14 @@ class Command:
             else:
                 print(__description__)
         except MissingActionDecorator as err:
-            print(message_icon, message_error, err)
+            print(settings.WARNING_ALERT, err)
 
         except ExecutionModeNotExist as err:
-            print(message_icon, message_error, err)
+            print(settings.WARNING_ALERT, err)
 
         except ModuleNotFound as err:
-            print(message_icon, message_error, err)
+            print(settings.WARNING_ALERT, err)
 
         except Exception as err:
-            print(message_icon, message_error, MESSAGE_UNKNOWN_ERROR)
-            logger.error(err)
+            logger.error(f"Internal problem: {str(err)}")
+            print(settings.ERROR_ALERT, MESSAGE_UNKNOWN_ERROR)

dotflow/cli/validators/start.py

@@ -13,4 +13,4 @@ class StartValidator(BaseModel):
     callable: Optional[str] = Field(default=None)
     initial_context: Optional[str] = Field(default=None)
     output: Optional[bool] = Field(default=True)
-    path: Optional[str] = Field(default=settings.INITIAL_PATH)
+    path: Optional[str] = Field(default=settings.START_PATH)

dotflow/core/config.py

@@ -1,6 +1,7 @@
 """Config module"""
 
-from dotflow.utils import make_dir
+from pathlib import Path
+
 from dotflow.settings import Settings as settings
 
 
@@ -8,11 +9,13 @@ class Config:
 
     def __init__(
             self,
-            path: str = settings.INITIAL_PATH,
+            path: str = settings.START_PATH,
             output: bool = False
     ) -> None:
-        self.path = path
-        self.log_path = f"{path}/{settings.LOG_FILE}"
+        self.path = Path(path)
+        self.task_path = Path(path, "tasks")
+        self.log_path = Path(path, settings.LOG_FILE_NAME)
         self.output = output
 
-        make_dir(path=self.path, show_log=True)
+        self.path.mkdir(parents=True, exist_ok=True)
+        self.task_path.mkdir(parents=True, exist_ok=True)

dotflow/core/decorators/time.py

@@ -7,6 +7,6 @@ def time(func):
     def inside(*args, **kwargs):
         start = datetime.now()
         task = func(*args, **kwargs)
-        task._set_duration((datetime.now() - start).total_seconds())
+        task.duration = (datetime.now() - start).total_seconds()
         return task
     return inside

dotflow/core/exception.py

@@ -1,10 +1,11 @@
 """Exception module"""
 
 MESSAGE_UNKNOWN_ERROR = "Unknown error, please check logs for more information."
-MESSAGE_MISSING_STEP_DECORATOR = "A step function necessarily needs an 'action' decorator to circulate in the workflow. For more implementation details, access the documentation: https://dotflow-io.github.io/dotflow/nav/getting-started/#3-task-function."
+MESSAGE_MISSING_STEP_DECORATOR = "A step function necessarily needs an '@action' decorator to circulate in the workflow. For more implementation details, access the documentation: https://dotflow-io.github.io/dotflow/nav/getting-started/#3-task-function."
+MESSAGE_NOT_CALLABLE_OBJECT = "Problem validating the '{name}' object type; this is not a callable object"
 MESSAGE_EXECUTION_NOT_EXIST = "The execution mode does not exist. Allowed parameter is 'sequential' and 'background'."
-MESSAGE_MODULE_NOT_FOUND = "Problem importing the python module, it probably doesn't exist or is wrong."
-
+MESSAGE_MODULE_NOT_FOUND = "Problem importing the python module '{module}'."
+MESSAGE_PROBLEM_ORDERING = "Problem with correctly ordering functions of the '{name}' class."
 
 class MissingActionDecorator(Exception):
 
@@ -24,7 +25,29 @@ class ExecutionModeNotExist(Exception):
 
 class ModuleNotFound(Exception):
 
-    def __init__(self):
+    def __init__(self, module: str):
         super(ModuleNotFound, self).__init__(
-            MESSAGE_MODULE_NOT_FOUND
+            MESSAGE_MODULE_NOT_FOUND.format(
+                module=module
+            )
         )
+
+
+class NotCallableObject(Exception):
+
+    def __init__(self, name: str):
+        super(NotCallableObject, self).__init__(
+            MESSAGE_NOT_CALLABLE_OBJECT.format(
+                name=name
+            )
+        )
+
+
+class ProblemOrdering(Exception):
+
+    def __init__(self, name: str):
+        super(ProblemOrdering, self).__init__(
+            MESSAGE_PROBLEM_ORDERING.format(
+                name=name
+            )
+        )

dotflow/core/execution.py

@@ -1,8 +1,11 @@
 """Execution module"""
 
 from uuid import UUID
-from typing import Callable
+from typing import Callable, List, Tuple
+from inspect import getsourcelines
+from types import FunctionType, NoneType
 
+from dotflow.logging import logger
 from dotflow.core.action import Action
 from dotflow.core.context import Context
 from dotflow.core.task import Task
@@ -13,6 +16,19 @@ from dotflow.core.decorators import time
 
 class Execution:
 
+    VALID_OBJECTS = [
+        str,
+        int,
+        float,
+        dict,
+        list,
+        tuple,
+        set,
+        bool,
+        FunctionType,
+        NoneType
+    ]
+
     def __init__(
         self,
         task: Task,
@@ -21,39 +37,80 @@ class Execution:
     ) -> None:
         self.task = task
         self.task.status = TaskStatus.IN_PROGRESS
-        self.task._set_workflow_id(workflow_id)
         self.task.previous_context = previous_context
+        self.task.workflow_id = workflow_id
 
         self._excution()
 
+    def _is_action(self, class_instance: Callable, func: Callable):
+        return (
+            callable(getattr(class_instance, func))
+            and not func.startswith("__")
+            and getattr(class_instance, func).__module__ is Action.__module__
+        )
+
+    def _execution_orderer(
+            self,
+            callable_list: List[str],
+            class_instance: Callable
+    ) -> Tuple[int, Callable]:
+        ordered_list = []
+
+        try:
+            inside_code = getsourcelines(class_instance.__class__)[0]
+
+            for callable_name in callable_list:
+                for index, code in enumerate(inside_code):
+                    if code.find(f"def {callable_name}") != -1:
+                        ordered_list.append((index, callable_name))
+
+            ordered_list.sort()
+            return ordered_list
+
+        except TypeError as err:
+            logger.error(f"Internal problem: {str(err)}")
+
+        for index, callable_name in enumerate(callable_list):
+            ordered_list.append((index, callable_name))
+
+        return ordered_list
+
     def _execution_with_class(self, class_instance: Callable):
-        context = Context(storage=[])
+        new_context = Context(storage=[])
         previous_context = self.task.previous_context
+        callable_list = [
+            func
+            for func in dir(class_instance)
+            if self._is_action(class_instance, func)
+        ]
+
+        ordered_list = self._execution_orderer(
+            callable_list=callable_list, class_instance=class_instance
+        )
+
+        for _, new in ordered_list:
+            new_object = getattr(class_instance, new)
+            try:
+                subcontext = new_object(
+                    initial_context=self.task.initial_context,
+                    previous_context=previous_context,
+                )
+                new_context.storage.append(subcontext)
+                previous_context = subcontext
+
+            except Exception:
+                subcontext = new_object(
+                    class_instance,
+                    initial_context=self.task.initial_context,
+                    previous_context=previous_context,
+                )
+                new_context.storage.append(subcontext)
+                previous_context = subcontext
 
-        for func_name in dir(class_instance):
-            additional_function = getattr(class_instance, func_name)
-
-            if isinstance(additional_function, Action):
-                try:
-                    current_context = additional_function(
-                        initial_context=self.task.initial_context,
-                        previous_context=previous_context,
-                    )
-                    context.storage.append(current_context)
-                    previous_context = current_context
-                except TypeError:
-                    current_context = additional_function(
-                        class_instance,
-                        initial_context=self.task.initial_context,
-                        previous_context=previous_context,
-                    )
-                    context.storage.append(current_context)
-                    previous_context = current_context
-
-        if not context.storage:
+        if not new_context.storage:
             return Context(storage=class_instance)
 
-        return context
+        return new_context
 
     @time
     def _excution(self):
@@ -63,12 +120,7 @@ class Execution:
                 previous_context=self.task.previous_context,
             )
 
-            object_attributes = [
-                type(getattr(current_context.storage, param)) is Action
-                for param in dir(current_context.storage)
-            ]
-
-            if True in object_attributes:
+            if type(current_context.storage) not in self.VALID_OBJECTS:
                 current_context = self._execution_with_class(
                     class_instance=current_context.storage
                 )

dotflow/core/module.py

@@ -30,7 +30,9 @@ class Module:
         if hasattr(module, cls._get_name(value)):
             return getattr(module, cls._get_name(value))
 
-        raise ModuleNotFound()
+        raise ModuleNotFound(
+            module=value
+        )
 
     @classmethod
     def _get_name(cls, value: str):

dotflow/core/task.py

@@ -2,16 +2,25 @@
 
 from uuid import UUID
 from typing import Any, Callable, List
+from time import strftime, localtime
 
-from dotflow.log import logger
+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
 from dotflow.core.module import Module
-from dotflow.core.exception import MissingActionDecorator
+from dotflow.core.exception import MissingActionDecorator, NotCallableObject
 from dotflow.core.types.status import TaskStatus
 from dotflow.settings import Settings as settings
-from dotflow.utils import basic_callback, traceback_error, message_error, copy_file
+from dotflow.utils import (
+    basic_callback,
+    traceback_error,
+    message_error,
+    write_file,
+    copy_file
+)
 
 
 class TaskInstance:
@@ -19,11 +28,12 @@ class TaskInstance:
     def __init__(self, *args, **kwargs) -> None:
         self.task_id = None
         self.workflow_id = None
-        self.step = None
-        self.callback = None
+        self._step = None
+        self._callback = None
+        self._previous_context = None
         self._initial_context = None
         self._current_context = None
-        self._previous_context = None
+        self._duration = None
         self._error = None
         self._status = None
         self._config = None
@@ -40,45 +50,52 @@ class Task(TaskInstance):
         workflow_id: UUID = None,
         config: Config = None,
     ) -> None:
-        super().__init__(task_id, step, callback, initial_context, workflow_id)
-        self.config = config
+        super().__init__(
+            task_id,
+            step,
+            callback,
+            initial_context,
+            workflow_id
+        )
         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
 
     @property
-    def status(self):
-        if not self._status:
-            return TaskStatus.NOT_STARTED
-        return self._status
+    def step(self):
+        return self._step
 
-    @status.setter
-    def status(self, value: TaskStatus) -> None:
-        self._status = value
+    @step.setter
+    def step(self, value: Callable):
+        new_step = value
 
-        logger.info("ID %s - %s - %s", self.workflow_id, self.task_id, value)
+        if isinstance(value, str):
+            new_step = Module(value=value)
+
+        if new_step.__module__ != Action.__module__:
+            raise MissingActionDecorator()
+
+        self._step = new_step
 
     @property
-    def error(self):
-        if not self._error:
-            return TaskError()
-        return self._error
+    def callback(self):
+        return self._callback
 
-    @error.setter
-    def error(self, value: Exception) -> None:
-        task_error = TaskError(value)
-        self._error = task_error
+    @callback.setter
+    def callback(self, value: Callable):
+        new_callback = value
 
-        logger.error(
-            "ID %s - %s - %s \n %s",
-            self.workflow_id,
-            self.task_id,
-            self.status,
-            task_error.traceback,
-        )
+        if isinstance(value, str):
+            new_callback = Module(value=value)
+
+        if not isinstance(new_callback, Callable):
+            raise NotCallableObject(name=str(new_callback))
+
+        self._callback = new_callback
 
     @property
     def previous_context(self):
@@ -90,6 +107,26 @@ class Task(TaskInstance):
     def previous_context(self, value: Context):
         self._previous_context = Context(value)
 
+        TaskController(task=self).controller_output_context(
+            content=self.previous_context.storage,
+            context_name="previous_context"
+        )
+
+    @property
+    def initial_context(self):
+        if not self._initial_context:
+            return Context()
+        return self._initial_context
+
+    @initial_context.setter
+    def initial_context(self, value: Context):
+        self._initial_context = Context(value)
+
+        TaskController(task=self).controller_output_context(
+            content=self.initial_context.storage,
+            context_name="initial_context"
+        )
+
     @property
     def current_context(self):
         if not self._current_context:
@@ -100,35 +137,52 @@ class Task(TaskInstance):
     def current_context(self, value: Context):
         self._current_context = Context(value)
 
-        if self.config.output:
-            logger.info(
-                "ID %s - %s - Current Context -> %s",
-                self.workflow_id,
-                self.task_id,
-                str(value.storage),
-            )
+        TaskController(task=self).controller_output_context(
+            content=self.current_context.storage,
+            context_name="current_context"
+        )
 
-        copy_file(source=settings.LOG_PATH, destination=self.config.log_path)
+    @property
+    def duration(self):
+        return self._duration
+
+    @duration.setter
+    def duration(self, value: float):
+        self._duration = value
 
     @property
-    def initial_context(self):
-        if not self._initial_context:
-            return Context()
-        return self._initial_context
+    def error(self):
+        if not self._error:
+            return TaskError()
+        return self._error
 
-    @initial_context.setter
-    def initial_context(self, value: Context):
-        self._initial_context = Context(value)
+    @error.setter
+    def error(self, value: Exception) -> None:
+        task_error = TaskError(value)
+        self._error = task_error
 
-        if self.config.output:
-            logger.info(
-                "ID %s - %s - Initial Context -> %s",
-                self.workflow_id,
-                self.task_id,
-                str(value),
-            )
+        logger.error(
+            "ID %s - %s - %s \n %s",
+            self.workflow_id,
+            self.task_id,
+            self.status,
+            task_error.traceback,
+        )
 
-        copy_file(source=settings.LOG_PATH, destination=self.config.log_path)
+        console = Console()
+        console.print_exception(show_locals=True)
+
+    @property
+    def status(self):
+        if not self._status:
+            return TaskStatus.NOT_STARTED
+        return self._status
+
+    @status.setter
+    def status(self, value: TaskStatus) -> None:
+        self._status = value
+
+        TaskController(task=self).controller_logger()
 
     @property
     def config(self):
@@ -140,12 +194,6 @@ class Task(TaskInstance):
     def config(self, value: Config):
         self._config = value
 
-    def _set_duration(self, value: float) -> None:
-        self.duration = value
-
-    def _set_workflow_id(self, value: UUID) -> None:
-        self.workflow_id = value
-
 
 class TaskError:
 
@@ -157,8 +205,12 @@ class TaskError:
 
 class TaskBuilder:
 
-    def __init__(self, config: Config, workflow_id: UUID = None) -> None:
-        self.queu: List[Task] = []
+    def __init__(
+            self,
+            config: Config,
+            workflow_id: UUID = None
+    ) -> None:
+        self.queu: List[Callable] = []
         self.workflow_id = workflow_id
         self.config = config
 
@@ -168,10 +220,14 @@ class TaskBuilder:
         callback: Callable = basic_callback,
         initial_context: Any = None,
     ) -> None:
-        step = Module(value=step)
-
-        if step.__module__ != Action.__module__:
-            raise MissingActionDecorator()
+        if isinstance(step, list):
+            for inside_step in step:
+                self.add(
+                    step=inside_step,
+                    callback=callback,
+                    initial_context=initial_context
+                )
+            return self
 
         self.queu.append(
             Task(
@@ -191,3 +247,45 @@ class TaskBuilder:
 
     def clear(self) -> None:
         self.queu.clear()
+
+    def reverse(self) -> None:
+        self.queu.reverse()
+
+
+class TaskController:
+
+    def __init__(self, task: Task):
+        self.task = task
+        self.default_time_format = "%Y-%m-%d %H:%M:%S"
+
+    def _get_body(self):
+        return "{time} ID: {workflow_id} - {task_id} - {task_status}".format(
+            time=strftime(self.default_time_format, localtime()),
+            workflow_id=self.task.workflow_id,
+            task_id=self.task.task_id,
+            task_status=self.task.status
+        )
+
+    def controller_logger(self):
+        logger.info(
+            "ID %s - %s - %s",
+            self.task.workflow_id,
+            self.task.task_id,
+            self.task.status,
+        )
+        copy_file(
+            source=settings.LOG_PATH,
+            destination=self.task.config.log_path
+        )
+
+    def controller_output_context(self, content: Any, context_name: str) -> None:
+        if self.task.config.output:
+            file_name = "{workflow_id}-{task_id}-{context_name}".format(
+                workflow_id=self.task.workflow_id.hex,
+                task_id=self.task.task_id,
+                context_name=context_name
+            )
+            write_file(
+                path=self.task.config.task_path.joinpath(file_name),
+                content=str(content)
+            )

dotflow/{log.py → logging.py}

@@ -3,25 +3,25 @@
 import logging
 import logging.config
 
-from dotflow.utils import make_dir
 from dotflow.settings import Settings as settings
 
-make_dir(path=settings.INITIAL_PATH, show_log=True)
+settings.START_PATH.mkdir(parents=True, exist_ok=True)
 
 logging.basicConfig(
     filename=settings.LOG_PATH,
+    format=settings.LOG_FORMAT,
     level=logging.INFO,
-    filemode="a"
+    filemode="a",
 )
 
 logger = logging.getLogger(settings.LOG_PROFILE)
-logger.setLevel(logging.DEBUG)
+logger.setLevel(logging.INFO)
 
 ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
+ch.setLevel(logging.INFO)
 
 formatter = logging.Formatter(
-    '%(asctime)s - %(levelname)s [%(name)s]: %(message)s'
+    settings.LOG_FORMAT
 )
 
 ch.setFormatter(formatter)

dotflow/settings.py

@@ -1,9 +1,19 @@
 """Settings"""
 
+from pathlib import Path
+
 
 class Settings:
 
-    INITIAL_PATH = ".output"
+    START_PATH = Path(".output")
+    GITIGNORE = Path(".gitignore")
+
     LOG_PROFILE = "dotflow"
-    LOG_FILE = "flow.log"
-    LOG_PATH = ".output/flow.log"
+    LOG_FILE_NAME = Path("flow.log")
+    LOG_PATH = Path(".output/flow.log")
+    LOG_FORMAT = "%(asctime)s - %(levelname)s [%(name)s]: %(message)s"
+
+    ICON = ":game_die:"
+    ERROR_ALERT = f"{ICON} [bold red]Error:[/bold red]"
+    INFO_ALERT = f"{ICON} [bold blue]Info:[/bold blue]"
+    WARNING_ALERT = f"{ICON} [bold yellow]Warning:[/bold yellow]"

dotflow/utils/__init__.py

@@ -2,7 +2,7 @@
 
 from dotflow.utils.error_handler import traceback_error, message_error
 from dotflow.utils.basic_functions import basic_function, basic_callback
-from dotflow.utils.tools import make_dir, copy_file
+from dotflow.utils.tools import make_dir, copy_file, write_file, read_file
 
 
 __all__ = [
@@ -11,5 +11,7 @@ __all__ = [
     "basic_function",
     "basic_callback",
     "make_dir",
-    "copy_file"
+    "copy_file",
+    "write_file",
+    "read_file"
 ]

dotflow/utils/tools.py

@@ -1,8 +1,9 @@
 """Tools"""
 
+import json
 import logging
 
-from os import makedirs
+from os import makedirs, system
 from shutil import copy
 
 
@@ -24,3 +25,23 @@ def copy_file(
     except Exception as err:
         if show_log:
             logging.error(err)
+
+
+def write_file(
+        path: str,
+        content: str,
+        mode: str = "w"
+) -> None:
+    if isinstance(content, dict) or isinstance(content, list):
+        content = json.dumps(content)
+
+    try:
+        with open(file=path, mode=mode, encoding="utf-8") as file:
+            file.write(content)
+    except Exception:
+        system(f"echo '{content}' > {path}")
+
+
+def read_file(path: str) -> str:
+    with open(file=path) as file:
+        return file.read()

{dotflow-0.8.2.dev2.dist-info → dotflow-0.9.0.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dotflow
-Version: 0.8.2.dev2
+Version: 0.9.0.dev2
 Summary: 🎲 Dotflow turns an idea into flow!
 License: MIT License
          

{dotflow-0.8.2.dev2.dist-info → dotflow-0.9.0.dev2.dist-info}/RECORD

@@ -1,50 +1,50 @@
-dotflow/__init__.py,sha256=NdhtJ9DSS7rAMVJDffrx4rNSjS90H6aFMx7926tooOg,435
+dotflow/__init__.py,sha256=B0YZtVSNAgNCAyDyhpN0V3xwjVJt-If9PKoW7J6FiRc,435
 dotflow/abc/__init__.py,sha256=UIk84jCJYoHAk4In_eVXAaFAnNE63lI3dVP5qunyBJs,32
 dotflow/abc/file.py,sha256=JNQa7Cy-kX3rX-3IJ8CXLWGajgYb0cFXIvAaPYv97Cw,346
 dotflow/abc/http.py,sha256=Py9DmkHw37tNUP_t7Z4O1NIMr5kohNgl0LUcgQIRFr4,383
 dotflow/abc/tcp.py,sha256=OTcwUDPA9YYHDp-B-L2Y-8F4A7rT6r-YFPQfwN3TnO4,570
 dotflow/cli/__init__.py,sha256=1NhA5RRAaAfhj3LdBgtC2eZ7WPZlmN0f-Kz-biUkUXE,27
-dotflow/cli/command.py,sha256=YG_3Za5VqD0AoxWcTY-iY1FdrZOvI71NQ_f_yc_ZaPQ,211
-dotflow/cli/commands/__init__.py,sha256=lAv_X7b-LJsjE-cjIR_IxVFmdGDSlEaloNPzs6cJ8jM,264
-dotflow/cli/commands/init.py,sha256=F7sbQCCpMPFWIgJKDInFUAIGRwSbZ2maMMBaINqn7K8,352
-dotflow/cli/commands/server.py,sha256=zk22EOzuGZPjraPPDs0_8wHt45iVCSFiAvpJ2s3EIwo,156
-dotflow/cli/commands/start.py,sha256=msxsRelAHZvb8sXCIDSqRfNimJPR1F8u2TsRlNm7a1I,836
-dotflow/cli/setup.py,sha256=o1w9o-ir6bQRloWSXRlOXT40FF1mddv91tfdHmpzmwY,3276
+dotflow/cli/command.py,sha256=RRly3DJCLc1NU9zuaZuNiTxLiB40afHD6lp4NPrkbpw,237
+dotflow/cli/commands/__init__.py,sha256=4EpWlJEMJwaQbLHQNeTugMKz3G16sDGN54pl3V-DKcg,255
+dotflow/cli/commands/init.py,sha256=ZQaq4lE5Gx6QQE4f2AtBtRq_6zyZ1_C4IgLIlbqo2gQ,511
+dotflow/cli/commands/log.py,sha256=brZJZva8fbK8UekG6_5AGelpQLRbTJOw7Uy122W96e0,571
+dotflow/cli/commands/start.py,sha256=8sf_6ZXgnDCquScqwkaVvUWM51hOdJZD2PjCMVmU7Bk,734
+dotflow/cli/setup.py,sha256=uBcQrij0Cx-sLqiVnpfnmnTKedIj7MnOXKkWZ1KRArU,3208
 dotflow/cli/validators/__init__.py,sha256=sf7g8WHowEt3N4Pe5Ec-Wmec__v3_Bfyf6uKOZwXcyk,128
-dotflow/cli/validators/start.py,sha256=gA54aY2d7wn2Y5sJS55UEunGnuYSftVbGSxW6iwQt_Q,433
+dotflow/cli/validators/start.py,sha256=Gzr69n7WGr5ytpDN9lk4kocWLvMVvLptam7msovXNJs,431
 dotflow/core/__init__.py,sha256=baoenc4kd9OQjCrnmOKRm9JRinEjd5xb7luCeyQ-npY,28
 dotflow/core/action.py,sha256=srSFBBJvgpTGcrmJHwRuVcElAkxta7kQjyGKA1voWfI,2051
-dotflow/core/config.py,sha256=yDdI2MBIwwNHCz29IKD2sjlQE-t1_y0bHFsFtOJq1HI,411
+dotflow/core/config.py,sha256=LaZ6LzInqAc91iyr7RRkEsCSSpvS3SsZtfJlMaPHliQ,519
 dotflow/core/context.py,sha256=7-6aTdeSp-XOpVFT028E_GdLyDKR6xZXNl-ws0n3xoI,315
 dotflow/core/decorators/__init__.py,sha256=g7U7swkYHDu67uHChcz-5IeoJ4sC6dA4ci_-zey8VJE,233
 dotflow/core/decorators/action.py,sha256=UfbshA95vWJqZPJaNiFN-zkVNKBc7-sp8Xii4I6w_r4,421
 dotflow/core/decorators/retry.py,sha256=Bki5MjnRlZKVbTjr7gE8zNNZoHJNsudPVUFeC07_Ciw,621
-dotflow/core/decorators/time.py,sha256=rcfzoQ3mL3zThrFioQQhU--Mc8c5JkHJOXQnwVWyUeo,275
+dotflow/core/decorators/time.py,sha256=Nfpt0RQ10gzLa9vVzZxYnhy6jjrY9_ADQqcr0krEWi0,271
 dotflow/core/dotflow.py,sha256=yU_gG5rNdj5N8_tdeMpq-TzS0z_pNRUrZVyMd15RuLM,834
-dotflow/core/exception.py,sha256=_fAcJmThczS5MBCq7XjpxypRXybSlOpqLOn3HK_v_Yg,1082
-dotflow/core/execution.py,sha256=ZB27hpoYLp-i-5ZXWoQo6vG8_sjOYDb7RNmdh_E9XFg,2711
-dotflow/core/module.py,sha256=cZ1gHDTo8NEtKMoPKDsJSSOJ8aqNuXe8eFZx7J5pD7Q,933
+dotflow/core/exception.py,sha256=hZvuAzE7BdoT56QQs8uUn5JJa2SK1mwmFWcNVnztqWI,1754
+dotflow/core/execution.py,sha256=mb2KdvXLuVAIcFUJPPPMj4de0W0l3RMJOg1U8h1b_Ew,4048
+dotflow/core/module.py,sha256=eq3FSllvMkmrjI-2SXQSZngoZWyFj8BfpSOtXGUlc8A,967
 dotflow/core/serializers/__init__.py,sha256=2b2vyCuXmvS8N_K-ePuCrWC9yvMqLPBMeORjAWS5U70,35
 dotflow/core/serializers/task.py,sha256=MC9AVKlHneGKO2vT14VE8s03X_FsTQzyuly4EICa0QM,687
 dotflow/core/serializers/transport.py,sha256=GbTTgS27OHkj15uwaAZMJ7oNXaOXcqUGGdO66zOORX4,535
 dotflow/core/serializers/workflow.py,sha256=zb5VWtcpfX-2IpI2_E11kPhffWiGvnrt7rmrGFYs6QI,255
-dotflow/core/task.py,sha256=WCvT8vtKPLB56TtwXLDXqjJtdp1z2vsSpGspJOzo6v4,5188
+dotflow/core/task.py,sha256=z9HWZFAbWCXOwc8kbgMS6D9pAmwSihPBs25ziFUNQ4U,7617
 dotflow/core/types/__init__.py,sha256=pn8t6hLMkDT4PeSyj0rZplptv7PQV_AYRqb2hdR7HCQ,188
 dotflow/core/types/execution.py,sha256=kYc5hEWB9V_vITMw9DyclchMRy6F4YKTZU5yW89dmVs,173
 dotflow/core/types/status.py,sha256=PNaTNRPlb0kYOIgks4Bxac7saQOpMhNtHLibVHVvFKQ,207
 dotflow/core/types/worflow.py,sha256=vd-12mX7hZwQrGEMwHsY1EfrqZDvFGFygi1TvUHpHSI,135
 dotflow/core/workflow.py,sha256=xV0QWZbm8MubzbUXms7t2PH2oM2VBBbXK8rjDZKXWWY,2025
-dotflow/log.py,sha256=M4yY6hwiw9KMktTp9hQyr2Qi71xHrdCqxORsAwHwkmE,565
+dotflow/logging.py,sha256=e4HEIxZ-A7RKJK2pTV-DkNUF2ATbfezjjJiQaRWwQSE,530
 dotflow/main.py,sha256=EBmtrOl3HA_VLWS76RMKKwxn30RMQdq7FeSn5aMb6CU,266
 dotflow/providers/__init__.py,sha256=LMWJOrHg08ZTRi2kjk6Fsi2hXUuiC7OSrYTqO7k_2ic,33
 dotflow/providers/zeromq.py,sha256=zKKyXR2QfKqOmL3WyoaeMy7wYMa6Uknx82S8-VkcgeA,1310
-dotflow/settings.py,sha256=mjIf8g4a6vJvZO4sR8birElcdzcdzHCkj5LDSSUGQJ8,151
-dotflow/utils/__init__.py,sha256=Q2XC4ijgk0BQ239gsiNlTWri7IdFJ5rPeSSY3BkdVN4,362
+dotflow/settings.py,sha256=hDoXWlIYWGRvaDqjJP4EW3Qhve51XNkDp6CQXJEXvJs,508
+dotflow/utils/__init__.py,sha256=b31Cfy2FN6TdR7U3ZTV9ca6J_ckJC_M-SgcefHmXJJo,420
 dotflow/utils/basic_functions.py,sha256=S-maghYauG5QkMtHdm7qNcxBkKkSoE4akHSiI178Bwg,131
 dotflow/utils/error_handler.py,sha256=z07U_Chd0FKcQH8CmBiQjhSXmDfQhzTv9c4q0sPj97A,508
-dotflow/utils/tools.py,sha256=jjSNzyuJD9mjBIS6k30k-Cwgh3OKE-Fo0jgY7cF1ONQ,499
-dotflow-0.8.2.dev2.dist-info/LICENSE,sha256=UnmVHQt00UH2v7RBXqtIo_0D3vGBh0ujTdBKPKopAFk,1072
-dotflow-0.8.2.dev2.dist-info/METADATA,sha256=Ar2A3x_iZtqXLFgOKUxkx5PGgnf0czGsa8ZV9a3LTk4,10280
-dotflow-0.8.2.dev2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-dotflow-0.8.2.dev2.dist-info/entry_points.txt,sha256=3AW0pYKZpaMW6WZmN3t71X0FuwxQdivmQwe47_6yBp4,45
-dotflow-0.8.2.dev2.dist-info/RECORD,,
+dotflow/utils/tools.py,sha256=0a_J7dug4m4JQhOEKQtQSQjaqhZaP9Q3r4UHKu5_ZsM,986
+dotflow-0.9.0.dev2.dist-info/LICENSE,sha256=UnmVHQt00UH2v7RBXqtIo_0D3vGBh0ujTdBKPKopAFk,1072
+dotflow-0.9.0.dev2.dist-info/METADATA,sha256=5iInmYx4CogzHQYOuwMoY5d3gZUkM-ldpWpgs0ZLqCs,10280
+dotflow-0.9.0.dev2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+dotflow-0.9.0.dev2.dist-info/entry_points.txt,sha256=3AW0pYKZpaMW6WZmN3t71X0FuwxQdivmQwe47_6yBp4,45
+dotflow-0.9.0.dev2.dist-info/RECORD,,

dotflow/cli/commands/server.py

@@ -1,9 +0,0 @@
-"""Command server module"""
-
-from dotflow.cli.command import Command
-
-
-class ServerCommand(Command):
-
-    def __init__(self, *args, **kwargs):
-        pass