dotflow 0.8.2.dev1__tar.gz → 0.9.0.dev1__tar.gz

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dotflow
-Version: 0.8.2.dev1
+Version: 0.9.0.dev1
 Summary: 🎲 Dotflow turns an idea into flow!
 License: MIT License
          
@@ -164,7 +164,7 @@ workflow.start()
 |03| [cli_with_mode](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_mode.py)                                             |
 |04| [cli_with_output_context](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_output_context.py)                         |
 |05| [cli_with_path](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_path.py)                                             |
-|06| [cli](https://github.com/dotflow-io/dotflow/blob/master/examples/cli.py)                                                                 |
+|06| [simple_cli](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_cli.py)                                                                 |
 |07| [simple_class_workflow](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_class_workflow.py)                             |
 |08| [simple_function_workflow_with_error](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_function_workflow_with_error.py) |
 |09| [simple_function_workflow](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_function_workflow.py)                       |

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/README.md

@@ -120,7 +120,7 @@ workflow.start()
 |03| [cli_with_mode](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_mode.py)                                             |
 |04| [cli_with_output_context](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_output_context.py)                         |
 |05| [cli_with_path](https://github.com/dotflow-io/dotflow/blob/master/examples/cli_with_path.py)                                             |
-|06| [cli](https://github.com/dotflow-io/dotflow/blob/master/examples/cli.py)                                                                 |
+|06| [simple_cli](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_cli.py)                                                                 |
 |07| [simple_class_workflow](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_class_workflow.py)                             |
 |08| [simple_function_workflow_with_error](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_function_workflow_with_error.py) |
 |09| [simple_function_workflow](https://github.com/dotflow-io/dotflow/blob/master/examples/simple_function_workflow.py)                       |

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/__init__.py

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

dotflow-0.9.0.dev1/dotflow/cli/command.py

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

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/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-0.9.0.dev1/dotflow/cli/commands/init.py

@@ -0,0 +1,19 @@
+"""Command init module"""
+
+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 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-0.9.0.dev1/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-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/cli/commands/start.py

@@ -3,17 +3,13 @@
 from os import system
 
 from dotflow import DotFlow, Config
-from dotflow.core.models.execution import TypeExecution
+from dotflow.core.types.execution import TypeExecution
 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-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/cli/setup.py

@@ -3,17 +3,21 @@
 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.core.utils.basic_functions import basic_callback
-from dotflow.core.models.execution import TypeExecution
+from dotflow.utils.basic_functions import basic_callback
+from dotflow.core.types.execution import TypeExecution
 from dotflow.core.exception import (
     MissingActionDecorator,
     ExecutionModeNotExist,
     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)
+            print(settings.ERROR_ALERT, MESSAGE_UNKNOWN_ERROR)

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/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-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/core/action.py

@@ -56,7 +56,8 @@ class Action(object):
 
         if type(self.func) is type:
             if hasattr(self.func, "__init__"):
-                self.params = [param for param in self.func.__init__.__code__.co_varnames]
+                if hasattr(self.func.__init__, "__code__"):
+                    self.params = [param for param in self.func.__init__.__code__.co_varnames]
 
     def _get_context(self, kwargs: Dict):
         context = {}

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

@@ -0,0 +1,21 @@
+"""Config module"""
+
+from pathlib import Path
+
+from dotflow.settings import Settings as settings
+
+
+class Config:
+
+    def __init__(
+            self,
+            path: str = settings.START_PATH,
+            output: bool = False
+    ) -> None:
+        self.path = Path(path)
+        self.task_path = Path(path, "tasks")
+        self.log_path = Path(path, settings.LOG_FILE_NAME)
+        self.output = output
+
+        self.path.mkdir(parents=True, exist_ok=True)
+        self.task_path.mkdir(parents=True, exist_ok=True)

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/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-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/core/exception.py

@@ -1,9 +1,10 @@
 """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}'."
 
 
 class MissingActionDecorator(Exception):
@@ -24,7 +25,20 @@ 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
+            )
         )
+

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/core/execution.py

@@ -6,7 +6,7 @@ from typing import Callable
 from dotflow.core.action import Action
 from dotflow.core.context import Context
 from dotflow.core.task import Task
-from dotflow.core.models import TaskStatus
+from dotflow.core.types import TaskStatus
 
 from dotflow.core.decorators import time
 
@@ -21,8 +21,8 @@ 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()
 
@@ -63,12 +63,12 @@ class Execution:
                 previous_context=self.task.previous_context,
             )
 
-            so_this_is_a_class = [
+            object_attributes = [
                 type(getattr(current_context.storage, param)) is Action
                 for param in dir(current_context.storage)
             ]
 
-            if True in so_this_is_a_class:
+            if True in object_attributes:
                 current_context = self._execution_with_class(
                     class_instance=current_context.storage
                 )

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/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-0.8.2.dev1 → dotflow-0.9.0.dev1}/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.models.status import TaskStatus
+from dotflow.core.exception import MissingActionDecorator, NotCallableObject
+from dotflow.core.types.status import TaskStatus
 from dotflow.settings import Settings as settings
-from dotflow.core.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-0.9.0.dev1/dotflow/core/types/__init__.py

@@ -0,0 +1,10 @@
+"""Types __init__ module."""
+
+from dotflow.core.types.execution import TypeExecution
+from dotflow.core.types.status import TaskStatus
+
+
+__all__ = [
+    "TypeExecution",
+    "TaskStatus"
+]

{dotflow-0.8.2.dev1 → dotflow-0.9.0.dev1}/dotflow/core/workflow.py

@@ -9,9 +9,9 @@ from typing import Callable, List
 from dotflow.core.context import Context
 from dotflow.core.execution import Execution
 from dotflow.core.exception import ExecutionModeNotExist
-from dotflow.core.models import TypeExecution, TaskStatus
+from dotflow.core.types import TypeExecution, TaskStatus
 from dotflow.core.task import Task
-from dotflow.core.utils import basic_callback
+from dotflow.utils import basic_callback
 
 
 class Workflow:

dotflow-0.8.2.dev1/dotflow/log.py → dotflow-0.9.0.dev1/dotflow/logging.py

@@ -3,25 +3,25 @@
 import logging
 import logging.config
 
-from dotflow.core.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-0.9.0.dev1/dotflow/settings.py

@@ -0,0 +1,19 @@
+"""Settings"""
+
+from pathlib import Path
+
+
+class Settings:
+
+    START_PATH = Path(".output")
+    GITIGNORE = Path(".gitignore")
+
+    LOG_PROFILE = "dotflow"
+    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-0.9.0.dev1/dotflow/utils/__init__.py

@@ -0,0 +1,17 @@
+"""Utils __init__ module."""
+
+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, write_file, read_file
+
+
+__all__ = [
+    "traceback_error",
+    "message_error",
+    "basic_function",
+    "basic_callback",
+    "make_dir",
+    "copy_file",
+    "write_file",
+    "read_file"
+]

dotflow-0.9.0.dev1/dotflow/utils/tools.py

@@ -0,0 +1,47 @@
+"""Tools"""
+
+import json
+import logging
+
+from os import makedirs, system
+from shutil import copy
+
+
+def make_dir(path: str, show_log: bool = False):
+    try:
+        makedirs(name=path, exist_ok=True)
+    except Exception as err:
+        if show_log:
+            logging.error(err)
+
+
+def copy_file(
+        source: str,
+        destination: str,
+        show_log: bool = False
+) -> None:
+    try:
+        copy(src=source, dst=destination)
+    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.dev1 → dotflow-0.9.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.8.2.dev1"
+version = "0.9.0.dev1"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -31,7 +31,7 @@ Documentation = "https://github.com/dotflow-io/dotflow/blob/master/README.md"
 
 [tool.poetry]
 name = "dotflow"
-version = "0.8.2.dev1"
+version = "0.9.0.dev1"
 description = "🎲 Dotflow turns an idea into flow!"
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"

dotflow-0.8.2.dev1/dotflow/cli/command.py

@@ -1,10 +0,0 @@
-"""Command module"""
-
-
-class Command:
-
-    def __init__(self, **kwargs):
-        self.params = kwargs.get("arguments")
-
-        if hasattr(self.params, "option"):
-            getattr(self, self.params.option)()

dotflow-0.8.2.dev1/dotflow/cli/commands/init.py

@@ -1,16 +0,0 @@
-"""Command init module"""
-
-from os import system, path
-
-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"):
-            system("echo '\n\n# Dotflow\n.output' >> .gitignore")

dotflow-0.8.2.dev1/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

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

@@ -1,18 +0,0 @@
-"""Config module"""
-
-from dotflow.core.utils import make_dir
-from dotflow.settings import Settings as settings
-
-
-class Config:
-
-    def __init__(
-            self,
-            path: str = settings.INITIAL_PATH,
-            output: bool = False
-    ) -> None:
-        self.path = path
-        self.log_path = f"{path}/{settings.LOG_FILE}"
-        self.output = output
-
-        make_dir(path=self.path, show_log=True)

dotflow-0.8.2.dev1/dotflow/core/models/__init__.py

@@ -1,10 +0,0 @@
-"""Types __init__ module."""
-
-from dotflow.core.models.execution import TypeExecution
-from dotflow.core.models.status import TaskStatus
-
-
-__all__ = [
-    "TypeExecution",
-    "TaskStatus"
-]

dotflow-0.8.2.dev1/dotflow/core/utils/__init__.py

@@ -1,15 +0,0 @@
-"""Utils __init__ module."""
-
-from dotflow.core.utils.error_handler import traceback_error, message_error
-from dotflow.core.utils.basic_functions import basic_function, basic_callback
-from dotflow.core.utils.tools import make_dir, copy_file
-
-
-__all__ = [
-    "traceback_error",
-    "message_error",
-    "basic_function",
-    "basic_callback",
-    "make_dir",
-    "copy_file"
-]

dotflow-0.8.2.dev1/dotflow/core/utils/tools.py

@@ -1,26 +0,0 @@
-"""Tools"""
-
-import logging
-
-from os import makedirs
-from shutil import copy
-
-
-def make_dir(path: str, show_log: bool = False):
-    try:
-        makedirs(name=path, exist_ok=True)
-    except Exception as err:
-        if show_log:
-            logging.error(err)
-
-
-def copy_file(
-        source: str,
-        destination: str,
-        show_log: bool = False
-) -> None:
-    try:
-        copy(src=source, dst=destination)
-    except Exception as err:
-        if show_log:
-            logging.error(err)

dotflow-0.8.2.dev1/dotflow/settings.py

@@ -1,9 +0,0 @@
-"""Settings"""
-
-
-class Settings:
-
-    INITIAL_PATH = ".output"
-    LOG_PROFILE = "dotflow"
-    LOG_FILE = "flow.log"
-    LOG_PATH = ".output/flow.log"