dotflow 0.8.2.dev1__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dotflow
-Version: 0.8.2.dev1
+Version: 0.9.0
 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}/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}/dotflow/__init__.py

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

dotflow-0.9.0/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}/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/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/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}/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}/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)
+            logger.error(f"Internal problem: {str(err)}")
+            print(settings.ERROR_ALERT, MESSAGE_UNKNOWN_ERROR)

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

@@ -0,0 +1,53 @@
+"""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_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 '{module}'."
+MESSAGE_PROBLEM_ORDERING = "Problem with correctly ordering functions of the '{name}' class."
+
+class MissingActionDecorator(Exception):
+
+    def __init__(self):
+        super(MissingActionDecorator, self).__init__(
+            MESSAGE_MISSING_STEP_DECORATOR
+        )
+
+
+class ExecutionModeNotExist(Exception):
+
+    def __init__(self):
+        super(ExecutionModeNotExist, self).__init__(
+            MESSAGE_EXECUTION_NOT_EXIST
+        )
+
+
+class ModuleNotFound(Exception):
+
+    def __init__(self, module: str):
+        super(ModuleNotFound, self).__init__(
+            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-0.9.0/dotflow/core/execution.py

@@ -0,0 +1,138 @@
+"""Execution module"""
+
+from uuid import UUID
+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
+from dotflow.core.types import TaskStatus
+
+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,
+        workflow_id: UUID,
+        previous_context: Context
+    ) -> None:
+        self.task = task
+        self.task.status = TaskStatus.IN_PROGRESS
+        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):
+        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
+
+        if not new_context.storage:
+            return Context(storage=class_instance)
+
+        return new_context
+
+    @time
+    def _excution(self):
+        try:
+            current_context = self.task.step(
+                initial_context=self.task.initial_context,
+                previous_context=self.task.previous_context,
+            )
+
+            if type(current_context.storage) not in self.VALID_OBJECTS:
+                current_context = self._execution_with_class(
+                    class_instance=current_context.storage
+                )
+
+            self.task.status = TaskStatus.COMPLETED
+            self.task.current_context = current_context
+
+        except Exception as err:
+            self.task.status = TaskStatus.FAILED
+            self.task.error = err
+
+        finally:
+            self.task.callback(content=self.task)
+
+        return self.task

{dotflow-0.8.2.dev1 → dotflow-0.9.0}/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):