flowweave 1.0.0__py3-none-any.whl

flowweave/__init__.py

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

flowweave/base.py

@@ -0,0 +1,52 @@
+# Standard library
+from enum import IntEnum
+from typing import IO, Optional
+
+class Result(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 FlowWeaveTaskRunner:
+    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]
+
+        print(*args, sep=sep, end=end, file=file, flush=flush)

flowweave/cli.py

@@ -0,0 +1,81 @@
+# Standard library
+import argparse
+import json
+from pathlib import Path
+
+# Third-party
+import colorama
+
+# Local application / relative imports
+from .flowweave import FlowWeave
+
+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) -> None:
+    flow_data = FlowWeave.load_and_validate_schema(file=setting_path, schema="flow")
+    op_dic = FlowWeave.get_op_dic(flow_data)
+    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:
+    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")
+        FlowWeave.run(setting_file=setting_path, parallel=args.parallel, show_log = args.log)
+        return
+
+    if args.command == "info":
+        if args.flow_file:
+            show_flow_op(setting_path, args.flow_file)
+        else:
+            show_available_op()
+        return
+
+    parser.print_help()

flowweave/flowweave.py

@@ -0,0 +1,346 @@
+# Standard library
+import copy
+import importlib
+import itertools
+import json
+import logging
+from pathlib import Path
+from importlib.resources import files
+
+# Third-party
+import jsonschema
+import yaml
+from prefect import flow, task, get_run_logger
+
+# Local application / relative imports
+from .base import Result, TaskData
+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 FlowWeaveTask():
+    task_class = None
+
+    @task
+    def start(prev_future, task_data: TaskData):
+        try:
+            task_instance = task_data.task_class.runner()
+        except AttributeError:
+            raise TypeError(f"{task_data.task_class} must define runner")
+
+        # set task member variables
+        setattr(task_instance, "task_data", task_data)
+        # options
+        for key, value in task_data.option.items():
+            if hasattr(task_instance, key):
+                setattr(task_instance, key, value)
+                if task_data.show_log:
+                    FlowWeave._print_log(f"Task option {key} found: store {value}")
+            else:
+                if task_data.show_log:
+                    FlowWeave._print_log(f"Task option {key} not found: ignore")
+
+        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
+            elif "pre_fail" == task_data.do_only:
+                run_task = True if (Result.FAIL == prev_future.get("result")) else False
+
+        if run_task:
+            FlowWeaveTask.message_task_start(prev_future, task_data)
+
+            try:
+                task_result = task_instance()
+            except Exception as e:
+                FlowMessage.error(e)
+                task_result = Result.FAIL
+
+            FlowMessage.task_end(task_data, task_result)
+        else:
+            FlowWeaveTask.message_task_ignore(prev_future, task_data)
+            task_result = Result.IGNORE
+
+        return {"name" : task_data.name, "option" : task_data.option, "result" : task_result}
+
+    def message_task_start(prev_future, task_data: TaskData):
+        if prev_future:
+            prev_task_name = prev_future.get("name")
+            FlowMessage.task_start_link(prev_task_name, task_data)
+        else:
+            FlowMessage.task_start(task_data)
+
+    def message_task_ignore(prev_future, task_data: TaskData):
+        if prev_future:
+            prev_task_name = prev_future.get("name")
+            FlowMessage.task_ignore_link(task_data, prev_task_name)
+        else:
+            FlowMessage.task_ignore(task_data)
+
+class FlowWeave():
+    @flow
+    def run(setting_file: str, parallel: bool = False, show_log: bool = False) -> list[str]:
+        if not show_log:
+            logging.getLogger("prefect").setLevel(logging.CRITICAL)
+
+        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(FlowWeave.run_flow.submit(flow_data=flow_data,
+                                                         global_cmb=comb,
+                                                         op_dic=op_dic,
+                                                         part=comb_count,
+                                                         all=all_count,
+                                                         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,
+                                            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
+
+    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):
+        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)
+
+        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("\\", "/"))
+
+        return return_dic
+
+    def _get_op_dic_from_setting_file(setting_file: str):
+        return_dic = dict()
+
+        setting = FlowWeave.load_and_validate_schema(setting_file, "op_code")
+        source_name = setting_file.removesuffix("/op_code.yml").replace("/", ".")
+
+        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)
+
+            return_dic[str(op)] = op_class
+
+        return return_dic
+
+    def _get_op_class(source_name: str, script_name: str):
+        file_path = Path(f"{source_name.replace('.', '/')}/{script_name}.py").resolve()
+        spec = importlib.util.spec_from_file_location(file_path.stem, file_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        op_class = getattr(module, "Task")
+
+        return op_class
+
+    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
+
+    @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
+
+        if show_log:
+            text = "= Flow =\n"
+            text += f"Stage: {flow_data.get('flow')}\n"
+            text += "========"
+            FlowWeave._print_log(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:
+                FlowWeave._print_log(str(stage_data))
+
+            result = FlowWeave._run_stage(stage_data, show_log)
+            if Result.FAIL == result:
+                flow_result = Result.FAIL
+
+            FlowMessage.stage_end(stage, part, all, flow_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 _print_log(text: str):
+        logger = get_run_logger()
+        stage_text_list = text.split("\n")
+        for text in stage_text_list:
+            logger.info(f"{text}")
+
+    def _run_stage(stage_data: StageData, show_log: bool = False):
+        stage_result = Result.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, None, None, show_log)
+                )
+
+        for f in all_futures:
+            result = f.result()
+            if Result.FAIL == result.get("result"):
+                stage_result = Result.FAIL
+
+        return stage_result
+
+    def _run_task(stage_data: dict, task_name: str, 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)
+
+        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 = copy.deepcopy(
+            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 = task_module.start.submit(None, task_data)
+        else:
+            future = task_module.start.submit(prev_future, task_data)
+
+        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, future, visited.copy(), show_log)
+            )
+
+        return futures

flowweave/message.py

@@ -0,0 +1,90 @@
+# Standard library
+from typing import IO, Optional
+
+# Third-party
+from colorama import Fore
+
+# Local application / relative imports
+from .base import Result, TaskData
+
+class FlowMessage:
+    @staticmethod
+    def _print(text: str) -> None:
+        print(text)
+
+    @staticmethod
+    def get_result_text(result: Result) -> str:
+        text = ""
+
+        if Result.SUCCESS == result:
+            text = f"{Fore.GREEN}SUCCESS"
+        elif Result.IGNORE == result:
+            text = f"{Fore.CYAN}IGNORE"
+        elif Result.FAIL == result:
+            text = f"{Fore.CYAN}FAIL"
+        else:
+            text = f"{Fore.RED}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_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: Result) -> 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: Result) -> 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: Result) -> 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/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/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-1.0.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: flowweave
+Version: 1.0.0
+Summary: YAML-based workflow runner for task orchestration
+Author: syatch
+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: prefect<3,>=2
+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-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+flowweave/__init__.py,sha256=FA0lhFSH-_LhDGGJKyazusNtboi79-iDOAngsCFrlPM,163
+flowweave/base.py,sha256=tw8yMrN1KQ3f65GAT60L0k1cX2Iz4KixYqhcgRjrF_Q,1517
+flowweave/cli.py,sha256=djDcW0XN7YN_DRmdKEXZC1Ob2JPfjSrXvgOdGVtE_kc,2453
+flowweave/flowweave.py,sha256=GtTNcnvHQNIg3qO6aHQusn0htAV3ja80SB8uHspHMsk,12964
+flowweave/message.py,sha256=duU4KMMS3LTGubTHO9iAghoRImtgBdxQJcgzVecRsFQ,3506
+flowweave/schema/flow.json,sha256=K7EAcH2KqniAPdNJWJdLiOYC77D2SGg50SOU2frC7LU,1810
+flowweave/schema/op_code.json,sha256=C9JeyBvSC6fA8Ss0exk3nsPjTRq_2XpK2gshvAcavbQ,414
+flowweave-1.0.0.dist-info/licenses/LICENSE,sha256=iN7x3Cz45_nCPCn23daVPqs0m_ZWPvTdayE2jg2OSmY,1203
+flowweave-1.0.0.dist-info/METADATA,sha256=PrX3pSQgb8FMJtHSHNbApOwGcXu9BB3-kUVSreV944o,566
+flowweave-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+flowweave-1.0.0.dist-info/entry_points.txt,sha256=qV4hkGzamuf-N1eNz-h_tRQ89Wa_py2jIdOSTeGAE1M,49
+flowweave-1.0.0.dist-info/top_level.txt,sha256=7fLs0F6CROwWhmjP9CyKODB25HJohoougiOCCL1YD_Y,10
+flowweave-1.0.0.dist-info/RECORD,,

flowweave-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flowweave-1.0.0.dist-info/entry_points.txt

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

flowweave-1.0.0.dist-info/licenses/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-1.0.0.dist-info/top_level.txt

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