dify-player 0.1.0__tar.gz

dify_player-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: dify-player
+Version: 0.1.0
+Summary: Minimal workflow runner for hand-authored Dify-like plans.
+Requires-Python: >=3.11
+Requires-Dist: Jinja2<4,>=3.1
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: httpx<0.29,>=0.27

dify_player-0.1.0/README.md

@@ -0,0 +1,148 @@
+# dify-player
+
+最小構成の Dify workflow ランナーです。  
+現在は strict plan JSON の実行、最小 Dify YAML の import、Python からの async ライブラリ利用をサポートしています。
+
+## Setup
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+## Library Usage
+
+### Quick Start
+
+ライブラリとして使う場合は `WorkflowEngine` を利用します。  
+`run_plan_data(...)` は strict plan JSON 相当の dict をそのまま受け取れます。
+
+```python
+from dify_player import WorkflowEngine
+from dify_player.models import to_data
+
+engine = WorkflowEngine()
+
+result = await engine.run_plan_data(
+    plan_data=plan_data,
+    inputs=inputs,
+)
+
+if result.status == "succeeded":
+    print(result.outputs)
+else:
+    print(result.error.code, result.error.message)
+
+payload = to_data(result)
+```
+
+返り値は `RunResult` です。`result.outputs`、`result.error`、`result.nodes` に実行結果が入ります。  
+HTTP レスポンスや JSON 化が必要な場合は `dify_player.models.to_data(...)` を使って dict に変換できます。
+
+### FastAPI Example
+
+FastAPI から呼ぶ場合は、アプリ lifespan で `httpx.AsyncClient` を 1 つ持ち、`WorkflowEngine` に注入するのが扱いやすいです。
+
+```python
+import httpx
+from fastapi import FastAPI, HTTPException
+
+from dify_player import WorkflowEngine
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import to_data
+
+app = FastAPI()
+engine = WorkflowEngine()
+
+
+@app.on_event("startup")
+async def startup() -> None:
+    app.state.http_client = httpx.AsyncClient()
+
+
+@app.on_event("shutdown")
+async def shutdown() -> None:
+    await app.state.http_client.aclose()
+
+
+@app.post("/workflow/run")
+async def run_workflow(payload: dict) -> dict:
+    try:
+        result = await engine.run_plan_data(
+            plan_data=payload["plan"],
+            inputs=payload["inputs"],
+            http_client=app.state.http_client,
+        )
+    except PlanValidationError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    return to_data(result)
+```
+
+### Public Interface
+
+`WorkflowEngine` には次の async API があります。
+
+- `await engine.run_plan_data(plan_data=..., inputs=..., run_id=None, logger=None, http_client=None)`
+- `await engine.run_plan(plan=..., inputs=..., run_id=None, logger=None, http_client=None)`
+- `await engine.run_compiled_plan(compiled_plan=..., inputs=..., run_id=None, logger=None, http_client=None)`
+
+使い分けは次のとおりです。
+
+- `run_plan_data`: Web API や JSON 入力から直接呼ぶ用途向け
+- `run_plan`: すでに `Plan` オブジェクトを組み立てている内部利用向け
+- `run_compiled_plan`: 同じ plan を何度も実行する用途向け
+
+### Logger And HTTP Client
+
+`logger` を渡さない場合、ライブラリ利用時はファイルログを書きません。  
+必要なら `run_id`, `log(...)`, `close()` を持つ logger を渡せます。
+
+`http_client` は任意です。
+
+- 渡した場合: 呼び出し側が所有し、このライブラリでは close しません
+- 渡さない場合: 実行ごとに内部で `httpx.AsyncClient` を生成して close します
+
+### Validation Behavior
+
+`run_plan_data(...)` は `plan_data` を `Plan` に変換する段階で `PlanValidationError` を送出することがあります。  
+一方、実行フェーズの失敗は `RunResult(status="failed")` として返ります。
+
+## CLI
+
+### Run
+
+手書きまたは import 済みの strict plan JSON を実行します。
+
+`plan.nodes[].name` は任意です。指定するとエラー表示とイベントログに `name [id]` 形式で出るため、Dify のどのノードか追いやすくなります。
+
+```bash
+python -m dify_player run examples/hello/plan.json examples/hello/input.json
+```
+
+ログを明示したい場合は `--log` を使います。
+
+```bash
+python -m dify_player run examples/hello/plan.json examples/hello/input.json --log logs/run.jsonl
+```
+
+### Import
+
+最小 Dify workflow YAML を strict plan JSON に変換します。
+
+```bash
+python -m dify_player import workflows/test_http_saas.yml output/plan.json
+```
+
+生成された `plan.json` は、そのまま `run` で実行できます。
+
+## Test HTTP Server
+
+HTTP ノードの確認用に、固定ポート `18080` のローカルサーバを起動できます。
+
+```bash
+python scripts/http_test_server.py
+```
+
+このサーバは `GET /json`, `GET /slow`, `GET /not-found`, `POST /echo` を返します。

dify_player-0.1.0/dify_player/__init__.py

@@ -0,0 +1,7 @@
+"""Minimal workflow runner package."""
+
+from dify_player.workflow_engine import WorkflowEngine
+
+__all__ = ["__version__", "WorkflowEngine"]
+
+__version__ = "0.1.0"

dify_player-0.1.0/dify_player/__main__.py

@@ -0,0 +1,4 @@
+from dify_player.cli import main
+
+
+raise SystemExit(main())

dify_player-0.1.0/dify_player/cli.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+from dify_player.dify_workflow_importer import load_dify_workflow_definition, plan_to_data
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import to_data
+from dify_player.plan_loader import compile_plan
+from dify_player.workflow_executor import WorkflowExecutor
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="dify_player")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    run_parser = subparsers.add_parser("run", help="Run a hand-authored workflow plan.")
+    run_parser.add_argument("plan", help="Path to a plan JSON file.")
+    run_parser.add_argument("input", help="Path to an input JSON file.")
+    run_parser.add_argument(
+        "--log",
+        dest="log_path",
+        help="Path to the JSONL log file. Defaults to logs/<timestamp>_<run_id>.jsonl.",
+    )
+
+    import_parser = subparsers.add_parser("import", help="Import a minimal Dify workflow YAML into a strict plan JSON.")
+    import_parser.add_argument("workflow", help="Path to a Dify workflow YAML file.")
+    import_parser.add_argument("plan", help="Path to write the imported strict plan JSON.")
+    return parser
+
+
+async def async_main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "import":
+        try:
+            plan = load_dify_workflow_definition(Path(args.workflow))
+            compile_plan(plan)
+        except (FileNotFoundError, OSError, PlanValidationError) as exc:
+            print(str(exc), file=sys.stderr)
+            return 1
+
+        output_path = Path(args.plan)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with output_path.open("w", encoding="utf-8") as handle:
+            json.dump(plan_to_data(plan), handle, ensure_ascii=False, indent=2)
+            handle.write("\n")
+        print(str(output_path))
+        return 0
+
+    if args.command != "run":
+        parser.error(f"unsupported command: {args.command}")
+
+    log_path = Path(args.log_path) if args.log_path else None
+    result = await WorkflowExecutor().run_plan_path(
+        plan_path=Path(args.plan),
+        input_path=Path(args.input),
+        log_path=log_path,
+    )
+    print(json.dumps(to_data(result), ensure_ascii=False))
+    return 0 if result.status == "succeeded" else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    return asyncio.run(async_main(argv))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dify_player-0.1.0/dify_player/dify_importer/__init__.py

@@ -0,0 +1,4 @@
+from dify_player.dify_importer.plan_serializer import plan_to_data
+from dify_player.dify_importer.workflow_loader import load_dify_workflow_definition
+
+__all__ = ["load_dify_workflow_definition", "plan_to_data"]

dify_player-0.1.0/dify_player/dify_importer/graph_parser.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from dify_player.exceptions import PlanValidationError
+
+SUPPORTED_DIFY_NODE_TYPES = {
+    "start",
+    "http-request",
+    "llm",
+    "template-transform",
+    "if-else",
+    "variable-aggregator",
+    "code",
+    "loop",
+    "end",
+}
+
+
+@dataclass(frozen=True)
+class ParsedDifyGraph:
+    node_specs: dict[str, dict[str, Any]]
+    raw_edges: list[dict[str, Any]]
+
+
+def parse_dify_graph(data: Any) -> ParsedDifyGraph:
+    if not isinstance(data, dict):
+        raise PlanValidationError("Dify workflow YAML must be an object at the top level")
+    if data.get("kind") != "app":
+        raise PlanValidationError("Dify workflow YAML must define kind=app")
+
+    app = data.get("app")
+    if not isinstance(app, dict) or app.get("mode") != "workflow":
+        raise PlanValidationError("Dify workflow YAML must define app.mode=workflow")
+
+    workflow = data.get("workflow")
+    if not isinstance(workflow, dict):
+        raise PlanValidationError("Dify workflow YAML must define workflow")
+
+    graph = workflow.get("graph")
+    if not isinstance(graph, dict):
+        raise PlanValidationError("Dify workflow YAML must define workflow.graph")
+
+    raw_nodes = graph.get("nodes")
+    raw_edges = graph.get("edges")
+    if not isinstance(raw_nodes, list) or not raw_nodes:
+        raise PlanValidationError("Dify workflow graph must define non-empty nodes")
+    if not isinstance(raw_edges, list):
+        raise PlanValidationError("Dify workflow graph must define edges as an array")
+
+    return ParsedDifyGraph(
+        node_specs=_build_node_specs(raw_nodes),
+        raw_edges=[_parse_raw_edge(raw_edge) for raw_edge in raw_edges],
+    )
+
+
+def _build_node_specs(raw_nodes: list[Any]) -> dict[str, dict[str, Any]]:
+    node_specs: dict[str, dict[str, Any]] = {}
+    start_count = 0
+    end_count = 0
+
+    for raw_node in raw_nodes:
+        if not isinstance(raw_node, dict):
+            raise PlanValidationError("each Dify graph node must be an object")
+        node_id = raw_node.get("id")
+        data = raw_node.get("data")
+        if not isinstance(node_id, str) or not node_id:
+            raise PlanValidationError("each Dify graph node must define a non-empty string id")
+        if not isinstance(data, dict):
+            raise PlanValidationError(f"Dify node {node_id!r} must define data")
+
+        node_type = data.get("type")
+        if not isinstance(node_type, str) or not node_type:
+            raise PlanValidationError(f"Dify node {node_id!r} must define data.type")
+        if node_type not in SUPPORTED_DIFY_NODE_TYPES:
+            raise PlanValidationError(f"Dify node {node_id!r} has unsupported type {node_type!r}")
+        if node_id in node_specs:
+            raise PlanValidationError(f"duplicate Dify node id {node_id!r}")
+
+        if node_type == "start":
+            start_count += 1
+        if node_type == "end":
+            end_count += 1
+
+        node_specs[node_id] = data
+
+    if start_count != 1:
+        raise PlanValidationError("Dify workflow must contain exactly one start node")
+    if end_count != 1:
+        raise PlanValidationError("Dify workflow must contain exactly one end node")
+
+    return node_specs
+
+
+def _parse_raw_edge(raw_edge: Any) -> dict[str, Any]:
+    if not isinstance(raw_edge, dict):
+        raise PlanValidationError("each Dify graph edge must be an object")
+    source = raw_edge.get("source")
+    target = raw_edge.get("target")
+    if not isinstance(source, str) or not isinstance(target, str):
+        raise PlanValidationError("Dify graph edge source and target must be strings")
+    return raw_edge

dify_player-0.1.0/dify_player/dify_importer/http_body_converter.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from dify_player.exceptions import PlanValidationError
+from dify_player.dify_importer.reference_converter import convert_value, replace_embedded_dify_references
+
+
+def convert_http_body(raw_body: Any, *, node_specs: dict[str, dict[str, Any]], context: str) -> Any | None:
+    if raw_body in (None, ""):
+        return None
+    if not isinstance(raw_body, dict):
+        return convert_value(raw_body, node_specs=node_specs, context=context)
+
+    body_type = raw_body.get("type")
+    if body_type == "none":
+        return None
+    if body_type == "json":
+        return _convert_json_http_body(raw_body, node_specs=node_specs, context=context)
+
+    if "data" not in raw_body:
+        raise PlanValidationError(f"{context} must define data when body.type is not none")
+    return convert_value(raw_body["data"], node_specs=node_specs, context=context)
+
+
+def _convert_json_http_body(raw_body: dict[str, Any], *, node_specs: dict[str, dict[str, Any]], context: str) -> dict[str, Any] | list[Any]:
+    raw_data = raw_body.get("data")
+    if not isinstance(raw_data, list) or len(raw_data) != 1:
+        raise PlanValidationError(f"{context} only supports a single raw JSON entry in Step 5")
+
+    entry = raw_data[0]
+    if not isinstance(entry, dict):
+        raise PlanValidationError(f"{context} must contain object entries")
+    if entry.get("key") != "":
+        raise PlanValidationError(f"{context} only supports an empty key for raw JSON entries in Step 5")
+    if entry.get("type") != "text":
+        raise PlanValidationError(f"{context} only supports text raw JSON entries in Step 5")
+
+    raw_value = entry.get("value")
+    if not isinstance(raw_value, str) or not raw_value:
+        raise PlanValidationError(f"{context} raw JSON entry must define a non-empty string value")
+
+    converted_json_text = replace_embedded_dify_references(
+        raw_value,
+        node_specs=node_specs,
+        context=f"{context} raw JSON value",
+    )
+    try:
+        converted_body = json.loads(converted_json_text)
+    except json.JSONDecodeError as exc:
+        raise PlanValidationError(f"{context} raw JSON value must be valid JSON after reference conversion") from exc
+
+    if not isinstance(converted_body, (dict, list)):
+        raise PlanValidationError(f"{context} raw JSON value must decode to an object or array")
+    return converted_body

dify_player-0.1.0/dify_player/dify_importer/node_converters/__init__.py

@@ -0,0 +1,23 @@
+from dify_player.dify_importer.node_converters.assigner import convert_assigner_node
+from dify_player.dify_importer.node_converters.code import convert_code_node
+from dify_player.dify_importer.node_converters.end import convert_end_node
+from dify_player.dify_importer.node_converters.http_request import convert_http_request_node
+from dify_player.dify_importer.node_converters.if_else import convert_if_else_node
+from dify_player.dify_importer.node_converters.llm import convert_llm_node
+from dify_player.dify_importer.node_converters.loop import convert_loop_node
+from dify_player.dify_importer.node_converters.start import convert_start_node
+from dify_player.dify_importer.node_converters.template_transform import convert_template_transform_node
+from dify_player.dify_importer.node_converters.variable_aggregator import convert_variable_aggregator_node
+
+__all__ = [
+    "convert_assigner_node",
+    "convert_code_node",
+    "convert_end_node",
+    "convert_http_request_node",
+    "convert_if_else_node",
+    "convert_llm_node",
+    "convert_loop_node",
+    "convert_start_node",
+    "convert_template_transform_node",
+    "convert_variable_aggregator_node",
+]

dify_player-0.1.0/dify_player/dify_importer/node_converters/assigner.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import Any
+
+from dify_player.dify_importer.reference_converter import convert_value_selector
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import Node
+
+
+def convert_assigner_node(
+    *,
+    node_id: str,
+    node_name: str | None,
+    data: dict[str, Any],
+    node_specs: dict[str, dict[str, Any]],
+) -> Node:
+    raw_items = data.get("items")
+    if not isinstance(raw_items, list) or not raw_items:
+        raise PlanValidationError(f"Dify assigner node {node_id!r} must define items as a non-empty array")
+
+    inputs: dict[str, Any] = {}
+    assignments: list[dict[str, str]] = []
+    target_names: set[str] = set()
+    for index, raw_item in enumerate(raw_items):
+        if not isinstance(raw_item, dict):
+            raise PlanValidationError(f"Dify assigner node {node_id!r} items[{index}] must be an object")
+        if raw_item.get("input_type") != "variable":
+            raise PlanValidationError(f"Dify assigner node {node_id!r} only supports items[{index}].input_type=variable")
+        if raw_item.get("operation") != "over-write":
+            raise PlanValidationError(f"Dify assigner node {node_id!r} only supports items[{index}].operation=over-write")
+
+        output_name = raw_item.get("output_name")
+        if not isinstance(output_name, str) or not output_name:
+            raise PlanValidationError(f"Dify assigner node {node_id!r} items[{index}].output_name must be a non-empty string")
+
+        loop_node_id, target_name = _parse_target_selector(
+            raw_item.get("variable_selector"),
+            node_id=node_id,
+            item_index=index,
+        )
+        if output_name != target_name:
+            raise PlanValidationError(
+                f"Dify assigner node {node_id!r} items[{index}] output_name must match target loop variable {target_name!r}"
+            )
+        if output_name in target_names:
+            raise PlanValidationError(
+                f"Dify assigner node {node_id!r} may not assign the same target more than once: {output_name!r}"
+            )
+        target_names.add(output_name)
+
+        input_name = f"input_{index}"
+        inputs[input_name] = convert_value_selector(
+            raw_item.get("value"),
+            node_specs=node_specs,
+            context=f"Dify assigner node {node_id!r} items[{index}].value",
+        )
+        assignments.append(
+            {
+                "input_name": input_name,
+                "target_name": target_name,
+                "target_scope": "loop_variable",
+                "operation": "overwrite",
+            }
+        )
+        _ = loop_node_id
+
+    return Node(
+        id=node_id,
+        kind="assigner",
+        name=node_name,
+        inputs=inputs,
+        config={"assignments": assignments},
+    )
+
+
+def _parse_target_selector(raw_value: Any, *, node_id: str, item_index: int) -> tuple[str, str]:
+    context = f"Dify assigner node {node_id!r} items[{item_index}].variable_selector"
+    if not isinstance(raw_value, list) or len(raw_value) != 2:
+        raise PlanValidationError(f"{context} must be exactly [loop_node_id, loop_var_name]")
+    loop_node_id, target_name = raw_value
+    if not isinstance(loop_node_id, str) or not loop_node_id:
+        raise PlanValidationError(f"{context}[0] must be a non-empty string loop node id")
+    if not isinstance(target_name, str) or not target_name:
+        raise PlanValidationError(f"{context}[1] must be a non-empty string loop variable name")
+    return loop_node_id, target_name

dify_player-0.1.0/dify_player/dify_importer/node_converters/code.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from dify_player.dify_importer.reference_converter import convert_value_selector
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import Node
+
+
+def convert_code_node(
+    *,
+    node_id: str,
+    node_name: str | None,
+    data: dict[str, Any],
+    node_specs: dict[str, dict[str, Any]],
+) -> Node:
+    language = data.get("code_language")
+    if language != "python3":
+        raise PlanValidationError(f"Dify code node {node_id!r} only supports code_language=python3")
+
+    source = data.get("code")
+    if not isinstance(source, str):
+        raise PlanValidationError(f"Dify code node {node_id!r} must define code as a string")
+
+    raw_variables = data.get("variables", [])
+    if raw_variables is None:
+        raw_variables = []
+    if not isinstance(raw_variables, list):
+        raise PlanValidationError(f"Dify code node {node_id!r} variables must be an array")
+
+    inputs: dict[str, Any] = {}
+    for index, item in enumerate(raw_variables):
+        if not isinstance(item, dict):
+            raise PlanValidationError(f"Dify code node {node_id!r} variables[{index}] must be an object")
+        variable = item.get("variable")
+        if not isinstance(variable, str) or not variable:
+            raise PlanValidationError(f"Dify code node {node_id!r} variables[{index}].variable must be a non-empty string")
+        inputs[variable] = convert_value_selector(
+            item.get("value_selector"),
+            node_specs=node_specs,
+            context=f"Dify code node {node_id!r} variables[{index}].value_selector",
+        )
+
+    raw_outputs = data.get("outputs")
+    if not isinstance(raw_outputs, dict):
+        raise PlanValidationError(f"Dify code node {node_id!r} must define outputs as an object")
+
+    outputs: list[str] = []
+    for output_name in raw_outputs:
+        if not isinstance(output_name, str) or not output_name:
+            raise PlanValidationError(f"Dify code node {node_id!r} outputs must use non-empty string keys")
+        outputs.append(output_name)
+
+    return Node(
+        id=node_id,
+        kind="code",
+        name=node_name,
+        inputs=inputs,
+        config={
+            "language": "python3",
+            "source": source,
+            "outputs": outputs,
+        },
+    )

dify_player-0.1.0/dify_player/dify_importer/node_converters/end.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Any
+
+from dify_player.dify_importer.reference_converter import convert_value_selector
+from dify_player.exceptions import PlanValidationError
+from dify_player.models import Node
+
+
+def convert_end_node(
+    *,
+    node_id: str,
+    node_name: str | None,
+    data: dict[str, Any],
+    node_specs: dict[str, dict[str, Any]],
+) -> Node:
+    outputs = data.get("outputs", [])
+    if outputs in ([], None):
+        return Node(id=node_id, kind="end", name=node_name, inputs={}, config={"outputs": {}})
+    if not isinstance(outputs, list):
+        raise PlanValidationError(f"Dify end node {node_id!r} outputs must be an array")
+
+    inputs: dict[str, Any] = {}
+    config_outputs: dict[str, str] = {}
+    for index, item in enumerate(outputs):
+        if not isinstance(item, dict):
+            raise PlanValidationError(f"Dify end node {node_id!r} outputs[{index}] must be an object")
+        variable = item.get("variable")
+        if not isinstance(variable, str) or not variable:
+            raise PlanValidationError(f"Dify end node {node_id!r} outputs[{index}].variable must be a non-empty string")
+        inputs[variable] = convert_value_selector(
+            item.get("value_selector"),
+            node_specs=node_specs,
+            context=f"Dify end node {node_id!r} outputs[{index}].value_selector",
+        )
+        config_outputs[variable] = _build_end_output_reference(variable)
+
+    return Node(id=node_id, kind="end", name=node_name, inputs=inputs, config={"outputs": config_outputs})
+
+
+def _build_end_output_reference(variable: str) -> str:
+    if variable.isidentifier():
+        return f"{{{{ inputs.{variable} }}}}"
+    return f"{{{{ inputs[{variable!r}] }}}}"