flowweave 2.0.0__tar.gz → 3.0.0__tar.gz

{flowweave-2.0.0 → flowweave-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowweave
-Version: 2.0.0
+Version: 3.0.0
 Summary: YAML-based workflow runner for task orchestration
 Author: syatch
 License: MIT

flowweave-3.0.0/flowweave/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "3.0.0"
+__author__ = "syatch"
+__license__ = "MIT"
+
+from .flowweave import FlowWeave
+from .base import FlowWeaveResult, FlowWeaveTask

{flowweave-2.0.0 → flowweave-3.0.0}/flowweave/base.py

@@ -4,7 +4,7 @@ from typing import IO, Optional
 
 from colorama import Fore
 
-class Result(IntEnum):
+class FlowWeaveResult(IntEnum):
     FAIL = 0
     SUCCESS = 1
     IGNORE = 2
@@ -30,17 +30,17 @@ class TaskData:
         self.do_only = do_only
         self.show_log = show_log
 
-class FlowWeaveTaskRunner:
+class FlowWeaveTask:
     def __init__(self, prev_future):
         self.prev_future = prev_future
         self.return_data = None
 
-    def __call__(self) -> Result:
-        result = self.run()
-        return result
+    def __call__(self):
+        result, return_data = self.run()
+        return result, return_data
 
-    def run(self) -> Result:
-        return Result.SUCCESS
+    def run(self):
+        return FlowWeaveResult.SUCCESS, self.return_data
 
     def set_task_data(self, task_data: TaskData) -> None:
         self.task_data = task_data

{flowweave-2.0.0 → flowweave-3.0.0}/flowweave/cli.py

@@ -8,7 +8,7 @@ import colorama
 
 # Local application / relative imports
 from .flowweave import FlowWeave
-from .base import Result
+from .base import FlowWeaveResult
 
 def get_setting_path(args):
     setting_path = None
@@ -23,9 +23,9 @@ def serialize(obj) -> str:
         return obj.__name__
     raise TypeError(f"Type {type(obj)} not serializable")
 
-def show_flow_op(setting_path: str, flow_name: str) -> None:
+def show_flow_op(setting_path: str, flow_name: str, info: bool = False) -> None:
     flow_data = FlowWeave.load_and_validate_schema(file=setting_path, schema="flow")
-    op_dic = FlowWeave.get_op_dic(flow_data)
+    op_dic = FlowWeave.get_op_dic(flow_data, info=info)
     print_op_dic(op_dic, flow_name)
 
 def show_available_op() -> None:
@@ -59,7 +59,7 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 def main() -> None:
-    result = Result.SUCCESS
+    result = FlowWeaveResult.SUCCESS
 
     colorama.init(autoreset=True)
 
@@ -72,10 +72,10 @@ def main() -> None:
         if not setting_path:
             parser.error("run requires flow_file")
         results = FlowWeave.run(setting_file=setting_path, parallel=args.parallel, show_log = args.log)
-        result = all(x == Result.SUCCESS for x in results)
+        result = all(x == FlowWeaveResult.SUCCESS for x in results)
     elif args.command == "info":
         if args.flow_file:
-            show_flow_op(setting_path, args.flow_file)
+            show_flow_op(setting_path, args.flow_file, info=True)
         else:
             show_available_op()
     else:

{flowweave-2.0.0 → flowweave-3.0.0}/flowweave/flowweave.py

@@ -1,7 +1,9 @@
 # Standard library
 import copy
+from functools import reduce
 import importlib
 from importlib.resources import files
+import inspect
 import itertools
 import json
 import logging
@@ -14,7 +16,7 @@ import yaml
 from prefect import flow, task, get_run_logger
 
 # Local application / relative imports
-from .base import Result, TaskData
+from .base import FlowWeaveResult, TaskData, FlowWeaveTask
 from .message import FlowMessage
 
 class StageData():
@@ -38,15 +40,13 @@ class StageData():
         text += "==========="
         return text
 
-class FlowWeaveTask():
-    task_class = None
-
+class TaskRunner():
     @task
     def start(prev_future, task_data: TaskData):
         try:
-            task_instance = task_data.task_class.runner(prev_future)
+            task_instance = task_data.task_class(prev_future)
         except AttributeError:
-            raise TypeError(f"{task_data.task_class} must define runner")
+            raise TypeError(f"Failed to get instance of '{task_data.task_class}'")
 
         # set task member variables
         setattr(task_instance, "task_data", task_data)
@@ -62,23 +62,23 @@ class FlowWeaveTask():
         run_task = True
         if prev_future:
             if "pre_success" == task_data.do_only:
-                run_task = True if (Result.SUCCESS == prev_future.get("result")) else False
+                run_task = True if (FlowWeaveResult.SUCCESS == prev_future.get("result")) else False
             elif "pre_fail" == task_data.do_only:
-                run_task = True if (Result.FAIL == prev_future.get("result")) else False
+                run_task = True if (FlowWeaveResult.FAIL == prev_future.get("result")) else False
 
         if run_task:
-            FlowWeaveTask.message_task_start(prev_future, task_data)
+            TaskRunner.message_task_start(prev_future, task_data)
 
             try:
                 task_result, return_data = task_instance()
             except Exception as e:
                 FlowMessage.error(e)
-                task_result = Result.FAIL
+                task_result = FlowWeaveResult.FAIL
 
             FlowMessage.task_end(task_data, task_result)
         else:
-            FlowWeaveTask.message_task_ignore(prev_future, task_data)
-            task_result = Result.IGNORE
+            TaskRunner.message_task_ignore(prev_future, task_data)
+            task_result = FlowWeaveResult.IGNORE
 
         return {"name" : task_data.name, "option" : task_data.option, "data" : return_data, "result" : task_result}
 
@@ -171,7 +171,7 @@ class FlowWeave():
 
         return data
 
-    def get_op_dic(flow_data: dict):
+    def get_op_dic(flow_data: dict, info: bool = False):
         return_dic = dict()
 
         op_source = flow_data.get("op_source")
@@ -179,7 +179,7 @@ class FlowWeave():
         for source in op_source_list:
             source_name = f"task/{source}"
             setting_file = f"{source_name.replace('.', '/')}/op_code.yml"
-            return_dic |= FlowWeave._get_op_dic_from_setting_file(setting_file)
+            return_dic |= FlowWeave._get_op_dic_from_setting_file(setting_file, info=info)
 
         return return_dic
 
@@ -207,27 +207,43 @@ class FlowWeave():
         op_dic = setting.get("op", {})
         for op, op_info in op_dic.items():
             script_name = op_info.get('script')
-            op_class = FlowWeave._get_op_class(source_name, script_name, info)
+            op_class = FlowWeave._get_op_class(source_name, script_name, FlowWeaveTask)
 
             return_dic[str(op)] = op_class
 
         return return_dic
 
-    def _get_op_class(source_name: str, script_name: str, info: bool = False):
+    def _get_op_class(source_name: str, script_name: str, base_class):
         module_name = f"{source_name}.{script_name}"
+
         try:
             module = importlib.import_module(module_name)
         except Exception as e:
             raise RuntimeError(f"Failed to import {module_name}: {e}")
 
-        if not hasattr(module, "Task"):
-            raise RuntimeError(f"'Task' class not found in {module_name}")
+        candidates = []
+
+        for _, obj in inspect.getmembers(module, inspect.isclass):
+            if obj.__module__ != module.__name__:
+                continue
 
-        return_module = module.Task
-        if info:
-            return_module = module.Task.runner
+            if issubclass(obj, base_class) and obj is not base_class:
+                candidates.append(obj)
 
-        return return_module
+        if len(candidates) == 0:
+            raise RuntimeError(
+                f"No subclass of {base_class.__name__} found in {module_name}"
+            )
+
+        if len(candidates) > 1:
+            names = ", ".join(c.__name__ for c in candidates)
+            raise RuntimeError(
+                f"Multiple subclasses of {base_class.__name__} found in {module_name}: {names}"
+            )
+
+        cls = candidates[0]
+
+        return cls
 
     def _get_global_option_comb(global_option: dict) -> list:
         keys = list(global_option.keys())
@@ -247,7 +263,7 @@ class FlowWeave():
 
     @task
     def run_flow(flow_data: dict, global_cmb: dict, op_dic: dict, part: int, all: int, show_log: bool = False) -> list[str]:
-        flow_result = Result.SUCCESS
+        flow_result = FlowWeaveResult.SUCCESS
 
         if show_log:
             text = "= Flow =\n"
@@ -269,8 +285,8 @@ class FlowWeave():
                 FlowWeave._print_log(str(stage_data))
 
             result = FlowWeave._run_stage(stage_data, show_log)
-            if Result.FAIL == result:
-                flow_result = Result.FAIL
+            if FlowWeaveResult.FAIL == result:
+                flow_result = FlowWeaveResult.FAIL
 
             FlowMessage.stage_end(stage, part, all, flow_result)
 
@@ -293,7 +309,7 @@ class FlowWeave():
             logger.info(f"{text}")
 
     def _run_stage(stage_data: StageData, show_log: bool = False):
-        stage_result = Result.SUCCESS
+        stage_result = FlowWeaveResult.SUCCESS
 
         all_futures = []
 
@@ -306,11 +322,23 @@ class FlowWeave():
 
         for f in all_futures:
             result = f.result()
-            if Result.FAIL == result.get("result"):
-                stage_result = Result.FAIL
+            if FlowWeaveResult.FAIL == result.get("result"):
+                stage_result = FlowWeaveResult.FAIL
 
         return stage_result
 
+    def _deep_merge(a: dict, b: dict) -> dict:
+        result = a.copy()
+        for k, v in b.items():
+            if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+                result[k] = FlowWeave._deep_merge(result[k], v)
+            else:
+                result[k] = v
+        return result
+
+    def _deep_merge_many(*dicts):
+        return reduce(FlowWeave._deep_merge, dicts)
+
     def _run_task(stage_data: dict, task_name: str, prev_future = None, visited = None, show_log: bool = False):
         if visited is None:
             visited = set()
@@ -326,11 +354,7 @@ class FlowWeave():
 
         default_option = stage_data.default_option or {}
         global_option = stage_data.global_option or {}
-        task_option = copy.deepcopy(
-            default_option
-            | global_option
-            | task_dic.get("option", {})
-        )
+        task_option = FlowWeave._deep_merge_many(default_option, global_option, task_dic.get("option", {}))
 
         task_data = TaskData(name=task_name,
                              task_class=task_module,
@@ -341,9 +365,9 @@ class FlowWeave():
                              do_only=task_dic.get("do_only"),
                              show_log=show_log)
         if prev_future is None:
-            future = task_module.start.submit(None, task_data)
+            future = TaskRunner.start.submit(None, task_data)
         else:
-            future = task_module.start.submit(prev_future, task_data)
+            future = TaskRunner.start.submit(prev_future, task_data)
 
         links = task_dic.get("chain", {}).get("next", [])
         links = links if isinstance(links, list) else [links]

{flowweave-2.0.0 → flowweave-3.0.0}/flowweave/message.py

@@ -5,7 +5,7 @@ from typing import IO, Optional
 from colorama import Fore
 
 # Local application / relative imports
-from .base import Result, TaskData
+from .base import FlowWeaveResult, TaskData
 
 class FlowMessage:
     @staticmethod
@@ -17,14 +17,14 @@ class FlowMessage:
         print(*args, sep=sep, end=end, file=file, flush=flush)
 
     @staticmethod
-    def get_result_text(result: Result) -> str:
+    def get_result_text(result: FlowWeaveResult) -> str:
         text = ""
 
-        if Result.SUCCESS == result:
+        if FlowWeaveResult.SUCCESS == result:
             text = f"{Fore.GREEN}SUCCESS"
-        elif Result.IGNORE == result:
+        elif FlowWeaveResult.IGNORE == result:
             text = f"{Fore.CYAN}IGNORE"
-        elif Result.FAIL == result:
+        elif FlowWeaveResult.FAIL == result:
             text = f"{Fore.RED}FAIL"
         else:
             text = f"{Fore.MAGENTA}UNKNOWN: {result.name}({result.value})"
@@ -42,7 +42,7 @@ class FlowMessage:
         FlowMessage._print(text)
 
     @staticmethod
-    def flow_end(part: int, all: int, result: Result) -> None:
+    def flow_end(part: int, all: int, result: FlowWeaveResult) -> None:
         result_text = FlowMessage.get_result_text(result)
         text = f"{Fore.YELLOW}[Flow {part} / {all}] Finish - {result_text}"
         FlowMessage._print(text)
@@ -53,7 +53,7 @@ class FlowMessage:
         FlowMessage._print(text)
 
     @staticmethod
-    def stage_end(stage: str, part: int, all: int, result: Result) -> None:
+    def stage_end(stage: str, part: int, all: int, result: FlowWeaveResult) -> None:
         result_text = FlowMessage.get_result_text(result)
         text = f"{Fore.MAGENTA}[Flow {part} / {all}] Finish Stage {stage} - {result_text}"
         FlowMessage._print(text)
@@ -79,7 +79,7 @@ class FlowMessage:
         FlowMessage._print(text)
 
     @staticmethod
-    def task_end(task_data: TaskData, result: Result) -> None:
+    def task_end(task_data: TaskData, result: FlowWeaveResult) -> None:
         result_text = FlowMessage.get_result_text(result)
         text = f"{Fore.CYAN}[Flow {task_data.flow_part} / {task_data.flow_all}] Finish Task {task_data.stage_name}/{task_data.name} - {result_text}"
         FlowMessage._print(text)

{flowweave-2.0.0 → flowweave-3.0.0}/flowweave.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowweave
-Version: 2.0.0
+Version: 3.0.0
 Summary: YAML-based workflow runner for task orchestration
 Author: syatch
 License: MIT

{flowweave-2.0.0 → flowweave-3.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowweave"
-version = "2.0.0"
+version = "3.0.0"
 description = "YAML-based workflow runner for task orchestration"
 authors = [{name = "syatch"}]
 readme = "README.md"

flowweave-2.0.0/flowweave/__init__.py

@@ -1,6 +0,0 @@
-__version__ = "2.0.0"
-__author__ = "syatch"
-__license__ = "MIT"
-
-from .flowweave import FlowWeave, FlowWeaveTask
-from .base import Result, TaskData, FlowWeaveTaskRunner