flowweave-lite 1.0.0__tar.gz

flowweave_lite-1.0.0/LICENSE

@@ -0,0 +1,24 @@
+This project depends on third-party open source software.
+Their licenses are governed by their respective authors.
+
+MIT License
+
+Copyright (c) 2026 syatch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flowweave_lite-1.0.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: flowweave-lite
+Version: 1.0.0
+Summary: YAML-based workflow runner for task orchestration (lite version of flowweave)
+Author: syatch
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: jsonschema>=4.25.0
+Requires-Dist: pyyaml<7,>=6
+Dynamic: license-file
+
+# FlowWeave
+YAML-based workflow runner for task orchestration
+
+This project is in early development.
+
+## Installation
+
+Install FlowWeave using pip:
+
+```bash
+pip install flowweave
+```

flowweave_lite-1.0.0/README.md

@@ -0,0 +1,12 @@
+# FlowWeave
+YAML-based workflow runner for task orchestration
+
+This project is in early development.
+
+## Installation
+
+Install FlowWeave using pip:
+
+```bash
+pip install flowweave
+```

flowweave_lite-1.0.0/flowweave/__init__.py

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

flowweave_lite-1.0.0/flowweave/base.py

@@ -0,0 +1,90 @@
+# Standard library
+from enum import IntEnum
+from typing import IO, Optional
+
+# Third-party
+from colorama import Fore
+
+# Local application / relative imports
+from .print_lock import print_lock
+
+class FlowWeaveResult(IntEnum):
+    FAIL = 0
+    SUCCESS = 1
+    IGNORE = 2
+
+class TaskData:
+    def __init__(self,
+                 name,
+                 task_class,
+                 option: dict,
+                 stage_name: str,
+                 flow_part: int,
+                 flow_all: int,
+                 do_only: str = None,
+                 show_log: bool = False):
+        self.name = name
+        self.task_class = task_class
+        self.option = option
+
+        self.stage_name = stage_name
+        self.flow_part = flow_part
+        self.flow_all = flow_all
+
+        self.do_only = do_only
+        self.show_log = show_log
+
+class FlowWeaveTask:
+    def __init__(self, prev_future):
+        self.prev_future = prev_future
+        self.return_data = None
+
+    def __call__(self):
+        result, return_data = self.run()
+        return result, return_data
+
+    def run(self):
+        return FlowWeaveResult.SUCCESS, self.return_data
+
+    def set_task_data(self, task_data: TaskData) -> None:
+        self.task_data = task_data
+
+    def message(self,
+                *args: object,
+                sep: str = " ",
+                end: str = "\n",
+                file: Optional[IO[str]] = None,
+                flush: bool = False) -> None:
+        if not self.task_data:
+            raise Exception("task_data is 'None'")
+
+        part_num = self.task_data.flow_part
+        all_num = self.task_data.flow_all
+        stage = self.task_data.stage_name
+        task = self.task_data.name
+        head = f"[Flow {part_num} / {all_num}] {stage}/{task}"
+
+        args = [f"{head}: {str(a)}" for a in args]
+
+        with print_lock:
+            print(*args, sep=sep, end=end, file=file, flush=flush)
+
+    def error(self,
+                *args: object,
+                sep: str = " ",
+                end: str = "\n",
+                file: Optional[IO[str]] = None,
+                flush: bool = False) -> None:
+        if not self.task_data:
+            raise Exception("task_data is 'None'")
+
+        part_num = self.task_data.flow_part
+        all_num = self.task_data.flow_all
+        stage = self.task_data.stage_name
+        task = self.task_data.name
+        head = f"[Flow {part_num} / {all_num}] {stage}/{task}"
+
+        args = [f"{head}: {Fore.RED}{str(a)}" for a in args]
+
+        with print_lock:
+            print(*args, sep=sep, end=end, file=file, flush=flush)

flowweave_lite-1.0.0/flowweave/cli.py

@@ -0,0 +1,84 @@
+# Standard library
+import argparse
+import json
+from pathlib import Path
+
+# Third-party
+import colorama
+
+# Local application / relative imports
+from .flowweave import FlowWeave
+from .base import FlowWeaveResult
+
+def get_setting_path(args):
+    setting_path = None
+
+    if args.flow_file:
+        setting_path = str(Path("flow") / f"{args.flow_file}.yml")
+
+    return setting_path
+
+def serialize(obj) -> str:
+    if isinstance(obj, type):
+        return obj.__name__
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+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, info=info)
+    print_op_dic(op_dic, flow_name)
+
+def show_available_op() -> None:
+    op_dic = FlowWeave.get_available_op_dic()
+    print_op_dic(op_dic)
+
+def print_op_dic(op_dic: dict, flow_name: str = "") -> None:
+    flow_text = ""
+    if "" != flow_name:
+        flow_text = f"in {flow_name} "
+    print(f"Operation code available {flow_text}(<op> : <class>)")
+    print(json.dumps(op_dic, indent=2, default=serialize))
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="flowweave")
+
+    subparsers = parser.add_subparsers(dest="command")
+    run_parser = subparsers.add_parser("run", help="Run a flow file")
+    run_parser.add_argument("flow_file", help="Path to YAML flow file")
+    run_parser.add_argument("-l", "--log", help="Show flow log", action='store_true')
+    run_parser.add_argument("-p", "--parallel", help="Run flow parallel", action='store_true')
+
+    info_parser = subparsers.add_parser("info", help="Show info")
+    info_parser.add_argument(
+        "flow_file",
+        nargs="?",
+        default=None,
+        help="Path to YAML flow file"
+    )
+
+    return parser
+
+def main() -> None:
+    result = FlowWeaveResult.SUCCESS
+
+    colorama.init(autoreset=True)
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    setting_path = get_setting_path(args)
+
+    if args.command == "run":
+        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 == FlowWeaveResult.SUCCESS for x in results)
+    elif args.command == "info":
+        if args.flow_file:
+            show_flow_op(setting_path, args.flow_file, info=True)
+        else:
+            show_available_op()
+    else:
+        parser.print_help()
+
+    return result

flowweave_lite-1.0.0/flowweave/flowweave.py

@@ -0,0 +1,420 @@
+# Standard library
+from concurrent.futures import ThreadPoolExecutor
+import copy
+from functools import reduce
+import importlib
+from importlib.resources import files
+import inspect
+import itertools
+import json
+import logging
+import os
+from pathlib import Path
+import sys
+
+# Third-party
+import jsonschema
+import yaml
+
+# Local application / relative imports
+from .base import FlowWeaveResult, TaskData, FlowWeaveTask
+from .message import FlowMessage
+
+class StageData():
+    def __init__(self, name: str, stage_info: dict, default_option: dict, global_option: dict, op_dic: dict, flow_part: int, flow_all: int):
+        self.name = name
+        self.stage_info = stage_info
+        self.default_option = default_option
+        self.global_option = global_option
+        self.op_dic = op_dic
+
+        self.flow_part = flow_part
+        self.flow_all = flow_all
+
+    def __str__(self):
+        text = "== Stage ==\n"
+        text += f"Name: {self.name}\n"
+        text += f"Stage Info: {self.stage_info}\n"
+        text += f"Default: {self.default_option}\n"
+        text += f"Global: {self.global_option}\n"
+        text += f"Operation: {self.op_dic}\n"
+        text += "==========="
+        return text
+
+class TaskRunner:
+    @staticmethod
+    def start(prev_result, task_data: TaskData):
+        return_data = None
+        try:
+            task_instance = task_data.task_class(prev_result)
+        except AttributeError:
+            raise TypeError(f"Failed to get instance of '{task_data.task_class}'")
+
+        setattr(task_instance, "task_data", task_data)
+
+        for key, value in task_data.option.items():
+            if hasattr(task_instance, key):
+                setattr(task_instance, key, value)
+
+        run_task = True
+        if prev_result is not None:
+            if task_data.do_only == "pre_success":
+                run_task = prev_result["result"] == FlowWeaveResult.SUCCESS
+            elif task_data.do_only == "pre_fail":
+                run_task = prev_result["result"] == FlowWeaveResult.FAIL
+
+        if run_task:
+            TaskRunner.message_task_start(prev_result, task_data)
+
+            try:
+                task_result, return_data = task_instance()
+            except Exception as e:
+                FlowMessage.error(e)
+                task_result = FlowWeaveResult.FAIL
+                return_data = None
+
+            FlowMessage.task_end(task_data, task_result)
+        else:
+            TaskRunner.message_task_ignore(prev_result, task_data)
+            task_result = FlowWeaveResult.IGNORE
+            return_data = None
+
+        return {
+            "name": task_data.name,
+            "option": task_data.option,
+            "data": return_data,
+            "result": task_result,
+        }
+
+    def message_task_start(prev_result, task_data: TaskData):
+        if prev_result is not None:
+            prev_task_name = prev_result.get("name")
+            FlowMessage.task_start_link(prev_task_name, task_data)
+        else:
+            FlowMessage.task_start(task_data)
+
+    def message_task_ignore(prev_result, task_data: TaskData):
+        if prev_result is not None:
+            prev_task_name = prev_result.get("name")
+            FlowMessage.task_ignore_link(task_data, prev_task_name)
+        else:
+            FlowMessage.task_ignore(task_data)
+
+class FlowWeave():
+    def run(setting_file: str, parallel: bool = False, show_log: bool = False) -> list[FlowWeaveResult]:
+        if not show_log:
+            logging.getLogger("prefect").setLevel(logging.CRITICAL)
+
+        flow_executor = ThreadPoolExecutor(max_workers=os.cpu_count())
+        task_executor = ThreadPoolExecutor(max_workers=min(32, (os.cpu_count() or 1) + 4))
+
+        try:
+            flow_data = FlowWeave.load_and_validate_schema(setting_file, "flow")
+
+            op_dic = FlowWeave.get_op_dic(flow_data)
+
+            global_option = flow_data.get("global_option")
+            comb_list = list()
+            if global_option:
+                comb_list = FlowWeave._get_global_option_comb(global_option)
+            else:
+                comb_list = [{}]
+
+            comb_count = 0
+            all_count = len(comb_list)
+            futures = []
+            results = []
+            for comb in comb_list:
+                comb_count += 1
+                FlowMessage.flow_start(comb_count, all_count)
+                FlowMessage.flow_message(comb_count, all_count, comb)
+                if parallel:
+                    futures.append(flow_executor.submit(FlowWeave.run_flow,
+                                                flow_data=flow_data,
+                                                global_cmb=comb,
+                                                op_dic=op_dic,
+                                                part=comb_count,
+                                                all=all_count,
+                                                executor=task_executor,
+                                                show_log=show_log))
+                else:
+                    result = FlowWeave.run_flow(flow_data=flow_data,
+                                                global_cmb=comb,
+                                                op_dic=op_dic,
+                                                part=comb_count,
+                                                all=all_count,
+                                                executor=task_executor,
+                                                show_log=show_log)
+                    results.append(result)
+                    FlowMessage.flow_end(comb_count, all_count, result)
+
+            if parallel:
+                comb_count = 0
+                for f in futures:
+                    comb_count += 1
+                    result = f.result()
+                    results.append(result)
+                    FlowMessage.flow_end(comb_count, all_count, result)
+
+            return results
+        finally:
+            flow_executor.shutdown(wait=True)
+            task_executor.shutdown(wait=True)
+
+    def load_and_validate_schema(file: str, schema: str) -> dict:
+        data = FlowWeave._load_yaml(file)
+        schema = FlowWeave._load_schema(schema)
+        jsonschema.validate(instance=data, schema=schema)
+
+        return data
+
+    def _load_yaml(path: str) -> dict:
+        file_path = Path(path)
+        if not file_path.exists() or not file_path.is_file():
+            raise FileNotFoundError(f"{file_path.resolve()} does not exist or not file")
+
+        with open(Path(path), "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        return data
+
+    def _load_schema(schema: str) -> dict:
+        schema_path = files("flowweave")/ "schema" / f"{schema}.json"
+        with schema_path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        return data
+
+    def get_op_dic(flow_data: dict, info: bool = False):
+        return_dic = dict()
+
+        op_source = flow_data.get("op_source")
+        op_source_list = op_source if isinstance(op_source, list) else [op_source]
+        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, info=info)
+
+        return return_dic
+
+    def get_available_op_dic():
+        return_dic = dict()
+
+        base_path = Path("task")
+        avaliable_settings = [str(f) for f in base_path.rglob("op_code.yml")]
+        for setting in avaliable_settings:
+            place = setting.replace("\\", ".").removeprefix("task.").removesuffix(".op_code.yml")
+            return_dic[place] = FlowWeave._get_op_dic_from_setting_file(setting.replace("\\", "/"), info=True)
+
+        return return_dic
+
+    def _get_op_dic_from_setting_file(setting_file: str, info: bool = False):
+        return_dic = dict()
+
+        setting = FlowWeave.load_and_validate_schema(setting_file, "op_code")
+        source_name = setting_file.removesuffix("/op_code.yml").replace("/", ".")
+
+        task_root = Path("task").resolve()
+        if str(task_root.parent) not in sys.path:
+            sys.path.insert(0, str(task_root.parent))
+
+        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, FlowWeaveTask)
+
+            return_dic[str(op)] = op_class
+
+        return return_dic
+
+    def _get_op_class(source_name: str, script_name: str, base_class):
+        module_name = f"{source_name}.{script_name}"
+
+        if module_name in sys.modules:
+            loaded_path = Path(sys.modules[module_name].__file__).resolve()
+            spec = importlib.util.find_spec(module_name)
+            if not spec or not spec.origin:
+                raise RuntimeError(f"Cannot resolve module path for {module_name}")
+
+            new_path = Path(spec.origin).resolve()
+
+            if loaded_path != new_path:
+                raise RuntimeError(
+                    f"Module name collision: {module_name}\n"
+                    f"Already loaded from: {loaded_path}\n"
+                    f"Trying to load from: {new_path}"
+                )
+
+        try:
+            module = importlib.import_module(module_name)
+        except Exception as e:
+            raise RuntimeError(f"Failed to import {module_name}: {e}")
+
+        candidates = []
+
+        for _, obj in inspect.getmembers(module, inspect.isclass):
+            if obj.__module__ != module.__name__:
+                continue
+
+            if issubclass(obj, base_class) and obj is not base_class:
+                candidates.append(obj)
+
+        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())
+        value_lists = []
+
+        for key in keys:
+            inner_dict = global_option[key]
+            value_lists.append([dict(zip(inner_dict.keys(), v))
+                                for v in itertools.product(*inner_dict.values())])
+
+        all_combinations = []
+        for combo in itertools.product(*value_lists):
+            combined = dict(zip(keys, combo))
+            all_combinations.append(combined)
+
+        return all_combinations
+
+    def run_flow(flow_data: dict, global_cmb: dict, op_dic: dict, part: int, all: int, executor: ThreadPoolExecutor, show_log: bool = False) -> FlowWeaveResult:
+        flow_result = FlowWeaveResult.SUCCESS
+
+        if show_log:
+            text = "= Flow =\n"
+            text += f"Stage: {flow_data.get('flow')}\n"
+            text += "========"
+            FlowMessage.flow_print(text)
+
+        default_option = flow_data.get("default_option", {})
+
+        stage_list = flow_data.get("flow")
+        for stage in stage_list:
+            FlowMessage.stage_start(stage, part, all)
+
+            stage_info = flow_data.get("stage", {}).get(stage)
+            stage_global_option = FlowWeave._get_stage_global_option(global_cmb, stage)
+
+            stage_data = StageData(stage, stage_info, default_option, stage_global_option, op_dic, part, all)
+            if show_log:
+                FlowMessage.flow_print(str(stage_data))
+
+            result = FlowWeave._run_stage(stage_data, executor, show_log)
+            if FlowWeaveResult.FAIL == result:
+                flow_result = FlowWeaveResult.FAIL
+
+            FlowMessage.stage_end(stage, part, all, result)
+
+        return flow_result
+
+    def _get_stage_global_option(global_cmb: dict, stage: str) -> dict:
+        stage_global_option = dict()
+
+        for stages, option in global_cmb.items():
+            stage_list = [x.strip() for x in stages.split(",")]
+            if stage in stage_list:
+                stage_global_option |= option
+
+        return stage_global_option
+
+    def _run_stage(stage_data: StageData, executor: ThreadPoolExecutor, show_log: bool = False):
+        stage_result = FlowWeaveResult.SUCCESS
+
+        all_futures = []
+
+        for task_name, task_dic in stage_data.stage_info.items():
+            part = task_dic.get("chain", {}).get("part", "head")
+            if "head" == part:
+                all_futures.extend(
+                    FlowWeave._run_task(stage_data, task_name, executor, None, None, show_log)
+                )
+
+        for f in all_futures:
+            try:
+                result = f.result()
+                if FlowWeaveResult.FAIL == result.get("result"):
+                    stage_result = FlowWeaveResult.FAIL
+            except Exception as e:
+                FlowMessage.error(e)
+                stage_result = FlowWeaveResult.FAIL
+                continue
+
+        return stage_result
+
+    def _deep_merge(a: dict, b: dict) -> dict:
+        result = copy.deepcopy(a)
+        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 _submit_task(prev_future, task_data, executor):
+        if prev_future is None:
+            return executor.submit(TaskRunner.start, None, task_data)
+
+        def runner():
+            prev_result = prev_future.result()
+            return TaskRunner.start(prev_result, task_data)
+
+        return executor.submit(runner)
+
+    def _run_task(stage_data: dict, task_name: str, executor: ThreadPoolExecutor, prev_future = None, visited = None, show_log: bool = False):
+        if visited is None:
+            visited = set()
+        if task_name in visited:
+            raise Exception(f"Cycle detected at task '{task_name}' in {visited}")
+        visited.add(task_name)
+        try:
+            task_dic = stage_data.stage_info.get(task_name)
+
+            task_module = stage_data.op_dic.get(task_dic.get('op'))
+            if not task_module:
+                raise Exception(f"module of op '{task_dic.get('op')}' for '{task_name}' not found")
+
+            default_option = stage_data.default_option or {}
+            global_option = stage_data.global_option or {}
+            task_option = FlowWeave._deep_merge_many(default_option, global_option, task_dic.get("option", {}))
+
+            task_data = TaskData(name=task_name,
+                                task_class=task_module,
+                                option=task_option,
+                                stage_name=stage_data.name,
+                                flow_part=stage_data.flow_part,
+                                flow_all=stage_data.flow_all,
+                                do_only=task_dic.get("do_only"),
+                                show_log=show_log)
+            if prev_future is None:
+                future = FlowWeave._submit_task(None, task_data, executor)
+            else:
+                future = FlowWeave._submit_task(prev_future, task_data, executor)
+
+            links = task_dic.get("chain", {}).get("next", [])
+            links = links if isinstance(links, list) else [links]
+
+            futures = [future]
+            for link in links:
+                futures.extend(
+                    FlowWeave._run_task(stage_data, link, executor, future, visited.copy(), show_log)
+                )
+
+            return futures
+
+        finally:
+            visited.remove(task_name)

flowweave_lite-1.0.0/flowweave/message.py

@@ -0,0 +1,101 @@
+# Standard library
+from typing import IO, Optional
+
+# Third-party
+from colorama import Fore
+
+# Local application / relative imports
+from .print_lock import print_lock
+from .base import FlowWeaveResult, TaskData
+
+class FlowMessage:
+    @staticmethod
+    def _print(*args: object,
+               sep: str = " ",
+               end: str = "\n",
+               file: Optional[IO[str]] = None,
+               flush: bool = False) -> None:
+        with print_lock:
+            print(*args, sep=sep, end=end, file=file, flush=flush)
+
+    @staticmethod
+    def get_result_text(result: FlowWeaveResult) -> str:
+        text = ""
+
+        if FlowWeaveResult.SUCCESS == result:
+            text = f"{Fore.GREEN}SUCCESS"
+        elif FlowWeaveResult.IGNORE == result:
+            text = f"{Fore.CYAN}IGNORE"
+        elif FlowWeaveResult.FAIL == result:
+            text = f"{Fore.RED}FAIL"
+        else:
+            text = f"{Fore.MAGENTA}UNKNOWN: {result.name}({result.value})"
+
+        return text
+
+    @staticmethod
+    def flow_start(part: int, all: int) -> None:
+        text = f"{Fore.YELLOW}[Flow {part} / {all}] Start"
+        FlowMessage._print(text)
+
+    @staticmethod
+    def flow_print(part: int, all: int, text: dict) -> None:
+        message = f"[Flow {part} / {all}] {text}"
+        FlowMessage._print(message)
+
+    @staticmethod
+    def flow_message(part: int, all: int, global_option: dict) -> None:
+        text = f"[Flow {part} / {all}] {global_option}"
+        FlowMessage._print(text)
+
+    @staticmethod
+    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)
+
+    @staticmethod
+    def stage_start(stage: str, part: int, all: int) -> None:
+        text = f"{Fore.MAGENTA}[Flow {part} / {all}] Start Stage {stage}"
+        FlowMessage._print(text)
+
+    @staticmethod
+    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)
+
+    @staticmethod
+    def task_start(task_data: TaskData) -> None:
+        text = f"{Fore.CYAN}[Flow {task_data.flow_part} / {task_data.flow_all}] Start Task {task_data.stage_name}/{task_data.name}"
+        FlowMessage._print(text)
+
+    @staticmethod
+    def task_start_link(prev_task: str, task_data: TaskData) -> None:
+        text = f"{Fore.CYAN}[Flow {task_data.flow_part} / {task_data.flow_all}] Start Link Task {task_data.stage_name}/{prev_task} -> {task_data.name}"
+        FlowMessage._print(text)
+
+    @staticmethod
+    def task_ignore(task_data: TaskData) -> None:
+        text = f"{Fore.CYAN}[Flow {task_data.flow_part} / {task_data.flow_all}] Ignore {task_data.name} (do_only : {task_data.do_only})"
+        FlowMessage._print(text)
+
+    @staticmethod
+    def task_ignore_link(task_data: TaskData, prev_task_name: str) -> None:
+        text = f"{Fore.CYAN}[Flow {task_data.flow_part} / {task_data.flow_all}] Ignore {prev_task_name} -> {task_data.name} (do_only : {task_data.do_only})"
+        FlowMessage._print(text)
+
+    @staticmethod
+    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)
+
+    @staticmethod
+    def error(*args: object,
+              sep: str = " ",
+              end: str = "\n",
+              file: Optional[IO[str]] = None,
+              flush: bool = False) -> None:
+        args = [f"{Fore.RED}{str(a)}" for a in args]
+        FlowMessage._print(*args, sep=sep, end=end, file=file, flush=flush)

flowweave_lite-1.0.0/flowweave/print_lock.py

@@ -0,0 +1,3 @@
+import threading
+
+print_lock = threading.Lock()

flowweave_lite-1.0.0/flowweave/schema/flow.json

@@ -0,0 +1,72 @@
+{
+  "type": "object",
+  "properties": {
+    "flow": {
+      "type": ["array", "string"],
+      "items": { "type": "string" }
+    },
+
+    "op_source": {
+      "type": ["array", "string"],
+      "items": { "type": "string" }
+    },
+
+    "global_option": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "array",
+          "items": {}
+        }
+      }
+    },
+
+    "default_option": {
+      "type": "object",
+      "additionalProperties": true
+    },
+
+    "stage": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "type": "object",
+          "patternProperties": {
+            ".*": {
+              "type": "object",
+              "properties": {
+                "op": { "type": "string" },
+
+                "do_only": {
+                  "type": "string",
+                  "enum": ["pre_success", "pre_fail"]
+                },
+                "chain": {
+                  "type": "object",
+                  "properties": {
+                    "part": { "type": "string" },
+                    "next": {
+                      "type": ["array", "string"],
+                      "items": { "type": "string" }
+                    }
+                  },
+                  "additionalProperties": false
+                },
+                "option": {
+                  "type": "object",
+                  "additionalProperties": true
+                }
+              },
+              "required": ["op"],
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": true
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "required": ["flow", "op_source", "stage"]
+}

flowweave_lite-1.0.0/flowweave/schema/op_code.json

@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "properties": {
+    "op": {
+      "type": "object",
+      "patternProperties": {
+        ".*": {
+          "type": "object",
+          "properties": {
+            "script": { "type": "string" }
+          },
+          "required": ["script"],
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["op"]
+}

flowweave_lite-1.0.0/flowweave_lite.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: flowweave-lite
+Version: 1.0.0
+Summary: YAML-based workflow runner for task orchestration (lite version of flowweave)
+Author: syatch
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: jsonschema>=4.25.0
+Requires-Dist: pyyaml<7,>=6
+Dynamic: license-file
+
+# FlowWeave
+YAML-based workflow runner for task orchestration
+
+This project is in early development.
+
+## Installation
+
+Install FlowWeave using pip:
+
+```bash
+pip install flowweave
+```

flowweave_lite-1.0.0/flowweave_lite.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+flowweave/__init__.py
+flowweave/base.py
+flowweave/cli.py
+flowweave/flowweave.py
+flowweave/message.py
+flowweave/print_lock.py
+flowweave/schema/flow.json
+flowweave/schema/op_code.json
+flowweave_lite.egg-info/PKG-INFO
+flowweave_lite.egg-info/SOURCES.txt
+flowweave_lite.egg-info/dependency_links.txt
+flowweave_lite.egg-info/entry_points.txt
+flowweave_lite.egg-info/requires.txt
+flowweave_lite.egg-info/top_level.txt

flowweave_lite-1.0.0/flowweave_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flowweave_lite-1.0.0/flowweave_lite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flowweave = flowweave.cli:main

flowweave_lite-1.0.0/flowweave_lite.egg-info/requires.txt

@@ -0,0 +1,3 @@
+colorama>=0.4.6
+jsonschema>=4.25.0
+pyyaml<7,>=6

flowweave_lite-1.0.0/flowweave_lite.egg-info/top_level.txt

@@ -0,0 +1 @@
+flowweave

flowweave_lite-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "flowweave-lite"
+version = "1.0.0"
+description = "YAML-based workflow runner for task orchestration (lite version of flowweave)"
+authors = [{name = "syatch"}]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "colorama>=0.4.6",
+    "jsonschema>=4.25.0",
+    "pyyaml>=6,<7"
+]
+license = { text = "MIT" }
+
+[tool.setuptools.packages.find]
+include = ["flowweave", "flowweave.*"]
+
+[tool.setuptools.package-data]
+"flowweave" = ["schema/*.json"]
+
+[project.scripts]
+flowweave = "flowweave.cli:main"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

flowweave_lite-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+