dotflow 0.8.0.dev1__tar.gz → 0.8.0.dev3__tar.gz

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/PKG-INFO

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

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/dotflow/__init__.py

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

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/dotflow/cli/commands/__init__.py

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

dotflow-0.8.0.dev3/dotflow/cli/commands/init.py

@@ -0,0 +1,16 @@
+"""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.0.dev1 → dotflow-0.8.0.dev3}/dotflow/cli/commands/start.py

@@ -1,6 +1,9 @@
-"""Command task module"""
+"""Command start module"""
+
+from os import system
 
 from dotflow import DotFlow, Config
+from dotflow.core.models.execution import TypeExecution
 from dotflow.cli.command import Command
 
 
@@ -14,7 +17,7 @@ class StartCommand(Command):
         workflow = DotFlow(
             config=Config(
                 path=self.params.path,
-                output=self.params.output
+                output=self.params.output_context
             )
         )
 
@@ -24,4 +27,9 @@ class StartCommand(Command):
             initial_context=self.params.initial_context
         )
 
-        workflow.start()
+        workflow.start(
+            mode=self.params.mode
+        )
+
+        if self.params.mode == TypeExecution.BACKGROUND:
+            system("/bin/bash")

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/dotflow/cli/setup.py

@@ -6,17 +6,15 @@ from dotflow import __version__, __description__
 from dotflow.log 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.core.exception import (
     MissingActionDecorator,
     ExecutionModeNotExist,
     StepMissingInit,
     ModuleNotFound,
-    MESSAGE_UNKNOWN_ERROR
-)
-from dotflow.cli.commands import (
-    ServerCommand,
-    StartCommand
+    MESSAGE_UNKNOWN_ERROR,
 )
+from dotflow.cli.commands import InitCommand, ServerCommand, StartCommand
 
 
 class Command:
@@ -31,30 +29,53 @@ class Command:
             "--version",
             action="version",
             version=f"dotflow=={__version__}",
-            help="Show program's version number and exit."
+            help="Show program's version number and exit.",
         )
 
+        self.setup_init()
         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 = 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(
+            "Usage: dotflow init [OPTIONS]"
+        )
+        self.cmd_init.set_defaults(exec=InitCommand)
+
     def setup_start(self):
-        self.cmd_start = self.subparsers.add_parser("start", help="Task")
-        self.cmd_start = self.cmd_start.add_argument_group("Usage: dotflow task [OPTIONS]")
+        self.cmd_start = self.subparsers.add_parser("start", help="Start")
+        self.cmd_start = self.cmd_start.add_argument_group(
+            "Usage: dotflow start [OPTIONS]"
+        )
 
         self.cmd_start.add_argument("-s", "--step", required=True)
         self.cmd_start.add_argument("-c", "--callback", default=basic_callback)
         self.cmd_start.add_argument("-i", "--initial-context")
-        self.cmd_start.add_argument("-o", "--output", default=False, action='store_true')
+        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(
+            "-m",
+            "--mode",
+            default=TypeExecution.SEQUENTIAL,
+            choices=[TypeExecution.SEQUENTIAL, TypeExecution.BACKGROUND],
+        )
 
         self.cmd_start.set_defaults(exec=StartCommand)
 
     def command(self):
+        message_icon = ":game_die:"
+        message_error = "[bold red]Error:[/bold red]"
+    
         try:
             arguments = self.parser.parse_args()
             if hasattr(arguments, "exec"):
@@ -62,17 +83,17 @@ class Command:
             else:
                 print(__description__)
         except MissingActionDecorator as err:
-            print(":game_die:", "[bold red]Error:[/bold red]", err)
+            print(message_icon, message_error, err)
 
         except ExecutionModeNotExist as err:
-            print(":game_die:", "[bold red]Error:[/bold red]", err)
+            print(message_icon, message_error, err)
 
         except StepMissingInit as err:
-            print(":game_die:", "[bold red]Error:[/bold red]", err)
+            print(message_icon, message_error, err)
 
         except ModuleNotFound as err:
-            print(":game_die:", "[bold red]Error:[/bold red]", err)
+            print(message_icon, message_error, err)
 
         except Exception as err:
-            print(":game_die:", "[bold red]Error:[/bold red]", MESSAGE_UNKNOWN_ERROR)
+            print(message_icon, message_error, MESSAGE_UNKNOWN_ERROR)
             logger.error(err)

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

@@ -26,19 +26,30 @@ class Execution:
 
         self._excution()
 
-    def _execution_with_class(self, step_class: Callable):
+    def _execution_with_class(self, class_instance: Callable):
         context = Context(storage=[])
 
-        for func_name in dir(step_class):
-            additional_function = getattr(step_class, func_name)
+        for func_name in dir(class_instance):
+            additional_function = getattr(class_instance, func_name)
             if isinstance(additional_function, Action):
                 try:
-                    context.storage.append(additional_function())
+                    context.storage.append(
+                        additional_function(
+                            initial_context=self.task.initial_context,
+                            previous_context=self.task.previous_context
+                        )
+                    )
                 except TypeError:
-                    context.storage.append(additional_function(step_class))
+                    context.storage.append(
+                        additional_function(
+                            class_instance,
+                            initial_context=self.task.initial_context,
+                            previous_context=self.task.previous_context
+                            )
+                    )
 
         if not context.storage:
-            return Context(storage=step_class)
+            return Context(storage=class_instance)
 
         return context
 
@@ -52,7 +63,7 @@ class Execution:
 
             if hasattr(current_context.storage.__init__, "__code__"):
                 current_context = self._execution_with_class(
-                    step_class=current_context.storage
+                    class_instance=current_context.storage
                 )
 
             self.task.status = TaskStatus.COMPLETED

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/dotflow/settings.py

@@ -3,7 +3,7 @@
 
 class Settings:
 
-    INITIAL_PATH = ".dotflow-io"
+    INITIAL_PATH = ".output"
     LOG_PROFILE = "dotflow"
     LOG_FILE = "flow.log"
-    LOG_PATH = ".dotflow-io/flow.log"
+    LOG_PATH = ".output/flow.log"

{dotflow-0.8.0.dev1 → dotflow-0.8.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.8.0.dev1"
+version = "0.8.0.dev3"
 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.0.dev1"
+version = "0.8.0.dev3"
 description = "🎲 Dotflow turns an idea into flow!"
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"