dotflow 0.12.0.dev1__tar.gz → 0.12.0.dev2__tar.gz

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/PKG-INFO

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

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/dotflow/__init__.py

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

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

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

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/dotflow/cli/commands/start.py

@@ -11,17 +11,7 @@ from dotflow.cli.command import Command
 class StartCommand(Command):
 
     def setup(self):
-        workflow = DotFlow()
-
-        if self.params.storage:
-            storage = {"default": StorageDefault, "file": StorageFile}
-
-            config = Config(
-                storage=storage.get(self.params.storage)(
-                    path=self.params.path,
-                )
-            )
-            workflow = DotFlow(config=config)
+        workflow = self._new_workflow()
 
         workflow.task.add(
             step=self.params.step,
@@ -33,3 +23,20 @@ class StartCommand(Command):
 
         if self.params.mode == TypeExecution.BACKGROUND:
             system("/bin/bash")
+
+    def _new_workflow(self):
+        if not self.params.storage:
+            return DotFlow()
+
+        storage_classes = {
+            "default": StorageDefault,
+            "file": StorageFile
+        }
+
+        config = Config(
+            storage=storage_classes.get(self.params.storage)(
+                path=self.params.path,
+            )
+        )
+
+        return DotFlow(config=config)

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/dotflow/cli/setup.py

@@ -6,18 +6,14 @@ from dotflow import __version__, __description__
 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
+from dotflow.core.types import TypeExecution, TypeStorage
 from dotflow.core.exception import (
     MissingActionDecorator,
     ExecutionModeNotExist,
     ImportModuleError,
     MESSAGE_UNKNOWN_ERROR,
 )
-from dotflow.cli.commands import (
-    InitCommand,
-    LogCommand,
-    StartCommand
-)
+from dotflow.cli.commands import InitCommand, LogCommand, StartCommand
 
 
 class Command:
@@ -56,13 +52,19 @@ class Command:
         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", "--storage", choices=["default", "file"])
+        self.cmd_start.add_argument(
+            "-o", "--storage", choices=[TypeStorage.DEFAULT, TypeStorage.FILE]
+        )
         self.cmd_start.add_argument("-p", "--path", default=settings.START_PATH)
         self.cmd_start.add_argument(
             "-m",
             "--mode",
             default=TypeExecution.SEQUENTIAL,
-            choices=[TypeExecution.SEQUENTIAL, TypeExecution.BACKGROUND],
+            choices=[
+                TypeExecution.SEQUENTIAL,
+                TypeExecution.BACKGROUND,
+                TypeExecution.PARALLEL,
+            ],
         )
 
         self.cmd_start.set_defaults(exec=StartCommand)

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/dotflow/core/dotflow.py

@@ -73,3 +73,6 @@ class DotFlow:
             list (List[Any]): Returns a list of assorted objects.
         """
         return [task.current_context.storage for task in self.task.queue]
+
+    def result(self):
+        return self.task.schema()

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

@@ -46,14 +46,14 @@ class Execution:
         task: Task,
         workflow_id: UUID,
         previous_context: Context = None,
-        internal_callback: Callable = basic_callback
+        _internal_callback: Callable = basic_callback
     ) -> None:
         self.task = task
         self.task.status = TaskStatus.IN_PROGRESS
         self.task.previous_context = previous_context
         self.task.workflow_id = workflow_id
 
-        self._excution(internal_callback)
+        self._excution(_internal_callback)
 
     def _is_action(self, class_instance: Callable, func: Callable):
         try:
@@ -131,7 +131,7 @@ class Execution:
         return new_context
 
     @time
-    def _excution(self, internal_callback):
+    def _excution(self, _internal_callback):
         try:
             current_context = self.task.step(
                 initial_context=self.task.initial_context,
@@ -157,6 +157,6 @@ class Execution:
 
         finally:
             self.task.callback(task=self.task)
-            internal_callback(task=self.task)
+            _internal_callback(task=self.task)
 
         return self.task

dotflow-0.12.0.dev2/dotflow/core/serializers/task.py

@@ -0,0 +1,47 @@
+"""Task serializer module"""
+
+import json
+
+from typing import Any, Optional
+from uuid import UUID
+
+from pydantic import BaseModel, Field, ConfigDict, field_validator  # type: ignore
+
+
+class SerializerTaskError(BaseModel):
+
+    traceback: str
+    message: str
+
+
+class SerializerTask(BaseModel):
+    model_config = ConfigDict(title="task")
+
+    task_id: int = Field(default=None)
+    workflow_id: Optional[UUID] = Field(default=None)
+    status: str = Field(default=None, alias="_status")
+    error: Optional[SerializerTaskError] = Field(default=None, alias="_error")
+    duration: Optional[float] = Field(default=None, alias="_duration")
+    initial_context: Any = Field(default=None, alias="_initial_context")
+    current_context: Any = Field(default=None, alias="_current_context")
+    previous_context: Any = Field(default=None, alias="_previous_context")
+    group_name: str = Field(default=None)
+
+    @field_validator("error", mode="before")
+    @classmethod
+    def error_validator(cls, value: str) -> str:
+        if value:
+            return SerializerTaskError(**value.__dict__)
+        return value
+
+    @field_validator(
+        "initial_context", "current_context", "previous_context", mode="before"
+    )
+    @classmethod
+    def context_validator(cls, value: str) -> str:
+        if value and value.storage:
+            try:
+                return json.dumps(value.storage)
+            except Exception:
+                return str(value)
+        return None

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/dotflow/core/serializers/workflow.py

@@ -1,11 +1,15 @@
 """Workflow serializer module"""
 
 from uuid import UUID
+from typing import List
 
 from pydantic import BaseModel, Field, ConfigDict  # type: ignore
 
+from dotflow.core.serializers.task import SerializerTask
+
 
 class SerializerWorkflow(BaseModel):
     model_config = ConfigDict(title="workflow")
 
     workflow_id: UUID = Field(default=None)
+    tasks: List[SerializerTask] = Field(default=[])

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

@@ -1,5 +1,7 @@
 """Task module"""
 
+import json
+
 from uuid import UUID
 from typing import Any, Callable, List
 
@@ -10,6 +12,8 @@ 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.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.utils import (
@@ -240,6 +244,13 @@ class Task(TaskInstance):
     def config(self, value: Config):
         self._config = value
 
+    def schema(self) -> SerializerTask:
+        item = SerializerTask(
+            **self.__dict__
+        ).model_dump_json()
+
+        return json.loads(item)
+
 
 class TaskError:
 
@@ -340,3 +351,11 @@ class TaskBuilder:
 
     def reverse(self) -> None:
         self.queue.reverse()
+
+    def schema(self) -> SerializerWorkflow:
+        item = SerializerWorkflow(
+            workflow_id=self.workflow_id,
+            tasks=[item.schema() for item in self.queue]
+        ).model_dump_json()
+
+        return json.loads(item)

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

@@ -2,9 +2,11 @@
 
 from dotflow.core.types.execution import TypeExecution
 from dotflow.core.types.status import TaskStatus
+from dotflow.core.types.storage import TypeStorage
 
 
 __all__ = [
     "TypeExecution",
-    "TaskStatus"
+    "TaskStatus",
+    "TypeStorage"
 ]

dotflow-0.12.0.dev2/dotflow/core/types/storage.py

@@ -0,0 +1,15 @@
+"""Type Storage mode"""
+
+from typing_extensions import Annotated, Doc
+
+
+class TypeStorage:
+    """
+    Import:
+        You can import the **TypeStorage** class with:
+
+            from dotflow.core.types import TypeStorage
+    """
+
+    DEFAULT: Annotated[str, Doc("Default storage.")] = "default"
+    FILE:  Annotated[str, Doc("File storage.")] = "file"

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

@@ -1,6 +1,8 @@
 """Workflow module"""
 
 import threading
+import warnings
+import platform
 
 from datetime import datetime
 from multiprocessing import Process, Queue
@@ -17,7 +19,13 @@ from dotflow.core.task import Task
 from dotflow.utils import basic_callback
 
 
+def is_darwin() -> bool:
+    """Is Darwin"""
+    return platform.system() == "Darwin"
+
+
 def grouper(tasks: List[Task]) -> Dict[str, List[Task]]:
+    """Grouper"""
     groups = {}
     for task in tasks:
         if not groups.get(task.group_name):
@@ -84,7 +92,7 @@ class Manager:
         failure: Callable = basic_callback,
         mode: TypeExecution = TypeExecution.SEQUENTIAL,
         keep_going: bool = False,
-        workflow_id: UUID = None
+        workflow_id: UUID = None,
     ) -> None:
         self.tasks = tasks
         self.success = success
@@ -101,10 +109,7 @@ class Manager:
             raise ExecutionModeNotExist() from err
 
         self.tasks = execution(
-            tasks=tasks,
-            workflow_id=workflow_id,
-            ignore=keep_going,
-            groups=groups
+            tasks=tasks, workflow_id=workflow_id, ignore=keep_going, groups=groups
         )
 
         self._callback_workflow(tasks=self.tasks)
@@ -118,7 +123,7 @@ class Manager:
             self.success(tasks=tasks)
 
     def sequential(self, **kwargs) -> List[Task]:
-        if len(kwargs.get("groups")) > 1:
+        if len(kwargs.get("groups", {})) > 1 and not is_darwin():
             process = SequentialGroup(**kwargs)
             return process.get_tasks()
 
@@ -134,11 +139,21 @@ class Manager:
         return process.get_tasks()
 
     def parallel(self, **kwargs) -> List[Task]:
+        if is_darwin():
+            warnings.warn(
+                "Parallel mode does not work with MacOS."
+                " Running tasks in sequence.",
+                Warning
+            )
+            process = Sequential(**kwargs)
+            return process.get_tasks()
+
         process = Parallel(**kwargs)
         return process.get_tasks()
 
 
 class Sequential(Flow):
+    """Sequential"""
 
     def setup_queue(self) -> None:
         self.queue = []
@@ -146,39 +161,37 @@ class Sequential(Flow):
     def get_tasks(self) -> List[Task]:
         return self.queue
 
-    def internal_callback(self, task: Task) -> None:
+    def _internal_callback(self, task: Task) -> None:
         self.queue.append(task)
 
     def run(self) -> None:
-        previous_context = Context(
-            workflow_id=self.workflow_id
-        )
+        previous_context = Context(workflow_id=self.workflow_id)
 
         for task in self.tasks:
             Execution(
                 task=task,
                 workflow_id=self.workflow_id,
                 previous_context=previous_context,
-                internal_callback=self.internal_callback
+                _internal_callback=self._internal_callback,
             )
 
             previous_context = task.config.storage.get(
                 key=task.config.storage.key(task=task)
             )
 
-            if not self.ignore:
-                if task.status == TaskStatus.FAILED:
-                    break
+            if not self.ignore and task.status == TaskStatus.FAILED:
+                break
 
 
 class SequentialGroup(Flow):
+    """SequentialGroup"""
 
     def setup_queue(self) -> None:
         self.queue = Queue()
 
     def get_tasks(self) -> List[Task]:
         contexts = {}
-        while len(contexts) < len(self.groups):
+        while len(contexts) < len(self.tasks):
             if not self.queue.empty():
                 contexts = {**contexts, **self.queue.get()}
 
@@ -191,41 +204,44 @@ class SequentialGroup(Flow):
 
         return self.tasks
 
-    def internal_callback(self, task: Task) -> None:
+    def _internal_callback(self, task: Task) -> None:
         current_task = {
             task.task_id: {
                 "current_context": task.current_context,
                 "duration": task.duration,
                 "error": task.error,
-                "status": task.status
+                "status": task.status,
             }
         }
         self.queue.put(current_task)
 
     def run(self) -> None:
-        thread_list = []
-        process_list = []
-
-        for group in self.groups:
-            def parallel(process_list):
-                process = Process(
-                    target=self.sequential,
-                    args=(self.groups[group],)
-                )
-                process.start()
-                process_list.append(process)
+        threads = []
+        processes = []
 
+        for _, group_tasks in self.groups.items():
             thread = threading.Thread(
-                target=parallel,
-                args=(process_list,)
+                target=self._launch_group,
+                args=(processes, group_tasks,)
             )
             thread.start()
-            thread_list.append(thread)
+            threads.append(thread)
+
+        for process in processes:
+            process.join()
+
+        for thread in threads:
+            thread.join()
 
-        [process.join() for process in process_list]
-        [thread.join() for thread in thread_list]
+    def _launch_group(self, processes, group_tasks):
+        process = Process(
+            target=self._run_group,
+            args=(group_tasks,)
+        )
+        process.start()
+        processes.append(process)
 
-    def sequential(self, groups: List[Task]) -> None:
+    def _run_group(self, groups: List[Task]) -> None:
         previous_context = Context(workflow_id=self.workflow_id)
 
         for task in groups:
@@ -233,19 +249,19 @@ class SequentialGroup(Flow):
                 task=task,
                 workflow_id=self.workflow_id,
                 previous_context=previous_context,
-                internal_callback=self.internal_callback
+                _internal_callback=self._internal_callback,
             )
 
             previous_context = task.config.storage.get(
                 key=task.config.storage.key(task=task)
             )
 
-            if not self.ignore:
-                if task.status == TaskStatus.FAILED:
-                    break
+            if not self.ignore and task.status == TaskStatus.FAILED:
+                break
 
 
 class Background(Flow):
+    """Background"""
 
     def setup_queue(self) -> None:
         self.queue = []
@@ -253,19 +269,25 @@ class Background(Flow):
     def get_tasks(self) -> List[Task]:
         return self.tasks
 
-    def internal_callback(self, task: Task) -> None:
+    def _internal_callback(self, task: Task) -> None:
         pass
 
     def run(self) -> None:
         thread = threading.Thread(
             target=Sequential,
-            args=(self.tasks, self.workflow_id, self.ignore, self.groups,)
+            args=(
+                self.tasks,
+                self.workflow_id,
+                self.ignore,
+                self.groups,
+            ),
         )
         thread.start()
         thread.join()
 
 
 class Parallel(Flow):
+    """Parallel"""
 
     def setup_queue(self) -> None:
         self.queue = Queue()
@@ -284,34 +306,28 @@ class Parallel(Flow):
 
         return self.tasks
 
-    def internal_callback(self, task: Task) -> None:
+    def _internal_callback(self, task: Task) -> None:
         current_task = {
             task.task_id: {
                 "current_context": task.current_context,
                 "duration": task.duration,
                 "error": task.error,
-                "status": task.status
+                "status": task.status,
             }
         }
         self.queue.put(current_task)
 
     def run(self) -> None:
-        process_list = []
-        previous_context = Context(
-            workflow_id=self.workflow_id
-        )
+        processes = []
+        previous_context = Context(workflow_id=self.workflow_id)
 
         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._internal_callback),
             )
             process.start()
-            process_list.append(process)
+            processes.append(process)
 
-        [process.join() for process in process_list]
+        for process in processes:
+            process.join()

{dotflow-0.12.0.dev1 → dotflow-0.12.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dotflow"
-version = "0.12.0.dev1"
+version = "0.12.0.dev2"
 authors = [
   { name="Fernando Celmer", email="email@fernandocelmer.com" },
 ]
@@ -35,7 +35,7 @@ mongodb = ["dotflow-mongodb"]
 
 [tool.poetry]
 name = "dotflow"
-version = "0.12.0.dev1"
+version = "0.12.0.dev2"
 description = "🎲 Dotflow turns an idea into flow!"
 authors = ["Fernando Celmer <email@fernandocelmer.com>"]
 readme = "README.md"

dotflow-0.12.0.dev1/dotflow/core/serializers/task.py

@@ -1,25 +0,0 @@
-"""Task serializer module"""
-
-from typing import Any, Optional
-from uuid import UUID
-
-from pydantic import BaseModel, Field, ConfigDict  # type: ignore
-
-
-class SerializerTaskError(BaseModel):
-
-    traceback: str
-    message: str
-
-
-class SerializerTask(BaseModel):
-    model_config = ConfigDict(title="task")
-
-    task_id: int = Field(default=None)
-    workflow_id: Optional[UUID] = Field(default=None)
-    status: str = Field(default=None)
-    error: Optional[SerializerTaskError] = Field(default=None)
-    duration: float = Field(default=None)
-    initial_context: Any = Field(default=None)
-    current_context: Any = Field(default=None)
-    previous_context: Any = Field(default=None)