dify-player 0.3.5__tar.gz → 0.3.7__tar.gz

{dify_player-0.3.5 → dify_player-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.5
+Version: 0.3.7
 Summary: Minimal workflow runner for hand-authored Dify-like plans.
 Requires-Python: >=3.11
 Requires-Dist: Jinja2<4,>=3.1

{dify_player-0.3.5 → dify_player-0.3.7}/README.md

@@ -87,9 +87,9 @@ async def run_workflow(payload: dict) -> dict:
 
 `WorkflowEngine` には次の async API があります。
 
-- `await engine.run_plan_data(plan_data=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
-- `await engine.run_plan(plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
-- `await engine.run_compiled_plan(compiled_plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None)`
+- `await engine.run_plan_data(plan_data=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None, provider_config=None)`
+- `await engine.run_plan(plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None, provider_config=None)`
+- `await engine.run_compiled_plan(compiled_plan=..., inputs=..., run_id=None, logger=None, http_client=None, llm_cache=False, llm_cache_store=None, provider_config=None)`
 
 使い分けは次のとおりです。
 
@@ -97,6 +97,32 @@ async def run_workflow(payload: dict) -> dict:
 - `run_plan`: すでに `Plan` オブジェクトを組み立てている内部利用向け
 - `run_compiled_plan`: 同じ plan を何度も実行する用途向け
 
+### Provider Config
+
+Azure OpenAI と Groq の接続設定は、実行単位で `provider_config` として渡せます。  
+優先順位は `provider_config`、`DIFY_PLAYER_*` 環境変数、既存互換の環境変数の順です。
+
+```python
+result = await engine.run_compiled_plan(
+    compiled_plan=compiled_plan,
+    inputs=inputs,
+    provider_config={
+        "azure_openai_endpoint": "https://example.openai.azure.com",
+        "azure_openai_api_key": "...",
+        "azure_openai_api_version": "2024-10-21",
+        "groq_api_key": "...",
+        "groq_api_base_url": "https://api.groq.com/openai/v1",
+    },
+)
+```
+
+対応する env fallback は次のとおりです。
+
+- Azure OpenAI: `DIFY_PLAYER_AZURE_OPENAI_ENDPOINT`, `DIFY_PLAYER_AZURE_OPENAI_API_KEY`, `DIFY_PLAYER_AZURE_OPENAI_API_VERSION`
+- Azure OpenAI 既存互換: `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_API_VERSION`
+- Groq: `DIFY_PLAYER_GROQ_API_KEY`, `DIFY_PLAYER_GROQ_API_BASE_URL`
+- Groq 既存互換: `GROQ_API_KEY`, `GROQ_API_BASE_URL`
+
 ### LLM Cache Mode
 
 workflow 改善中だけ LLM 応答を再利用したい場合は、`llm_cache=True` と cache store を渡します。  

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/__init__.py

@@ -5,4 +5,4 @@ from dify_player.workflow_engine import WorkflowEngine
 
 __all__ = ["__version__", "LLMCacheStore", "NullLLMCacheStore", "WorkflowEngine"]
 
-__version__ = "0.3.5"
+__version__ = "0.3.7"

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/dify_importer/node_converters/if_else.py

@@ -42,7 +42,7 @@ def convert_if_else_node(
                 )
             comparison_operator = raw_condition.get("comparison_operator")
             operator = _convert_comparison_operator(comparison_operator, node_id=node_id)
-            value = raw_condition.get("value")
+            value = raw_condition.get("value", "" if operator in {"empty", "not_empty"} else None)
             if not isinstance(value, str):
                 raise PlanValidationError(
                     f"Dify if-else node {node_id!r} cases[{case_index}].conditions[{condition_index}].value must be a string"
@@ -88,4 +88,8 @@ def _convert_comparison_operator(raw_value: Any, *, node_id: str) -> str:
         return "equals"
     if raw_value == "empty":
         return "empty"
-    raise PlanValidationError(f"Dify if-else node {node_id!r} only supports comparison_operator=contains, '=', or empty")
+    if raw_value == "not empty":
+        return "not_empty"
+    raise PlanValidationError(
+        f"Dify if-else node {node_id!r} only supports comparison_operator=contains, '=', empty, or not empty"
+    )

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/nodes/__init__.py

@@ -6,6 +6,7 @@ from typing import Any
 import httpx
 from dify_player.exceptions import UnsupportedNodeError
 from dify_player.models import Node
+from dify_player.provider_config import ProviderConfig
 
 from dify_player.nodes.assigner import run as run_assigner
 from dify_player.nodes.code import run as run_code
@@ -43,14 +44,18 @@ async def run_node(
     node_outputs: dict[str, dict[str, Any]],
     resolved_inputs: dict[str, Any],
     http_client: httpx.AsyncClient | None = None,
+    provider_config: ProviderConfig | None = None,
 ) -> dict[str, Any]:
     executor = _EXECUTORS.get(node.kind)
     if executor is None:
         raise UnsupportedNodeError(f"unsupported node kind {node.kind!r}")
-    return await executor(
-        node=node,
-        workflow_inputs=workflow_inputs,
-        node_outputs=node_outputs,
-        resolved_inputs=resolved_inputs,
-        http_client=http_client,
-    )
+    kwargs: dict[str, Any] = {
+        "node": node,
+        "workflow_inputs": workflow_inputs,
+        "node_outputs": node_outputs,
+        "resolved_inputs": resolved_inputs,
+        "http_client": http_client,
+    }
+    if node.kind in {"llm_azure_chat", "llm_groq_chat"}:
+        kwargs["provider_config"] = provider_config
+    return await executor(**kwargs)

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/nodes/if_else.py

@@ -41,6 +41,8 @@ def _matches_condition(*, condition: dict[str, Any], resolved_inputs: dict[str,
         return str(condition["value"]) in str(left_value)
     if condition["operator"] == "empty":
         return _is_empty(left_value)
+    if condition["operator"] == "not_empty":
+        return not _is_empty(left_value)
     if condition["operator"] == "equals":
         return str(left_value) == str(condition["value"])
     raise ValueError(f"unsupported if_else operator {condition['operator']!r}")

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/nodes/llm_azure_chat.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import json
-import os
 from typing import Any
 
 import httpx
 
 from dify_player.exceptions import AzureLLMBadStatusError, AzureLLMRequestFailedError, AzureLLMStructuredOutputError
 from dify_player.models import Node
+from dify_player.provider_config import ProviderConfig, resolve_provider_config_value
 from dify_player.value_renderer import render_value
 
 _STRUCTURED_OUTPUT_REPAIR_RETRIES = 1
@@ -20,11 +20,30 @@ async def run(
     node_outputs: dict[str, dict[str, Any]],
     resolved_inputs: dict[str, Any],
     http_client: httpx.AsyncClient | None = None,
+    provider_config: ProviderConfig | None = None,
 ) -> dict[str, Any]:
     _ = resolved_inputs
-    endpoint = _require_env("AZURE_OPENAI_ENDPOINT", node=node)
-    api_key = _require_env("AZURE_OPENAI_API_KEY", node=node)
-    api_version = _require_env("AZURE_OPENAI_API_VERSION", node=node)
+    endpoint = resolve_provider_config_value(
+        provider_config=provider_config,
+        config_key="azure_openai_endpoint",
+        env_names=("DIFY_PLAYER_AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_ENDPOINT"),
+        node=node,
+        required=True,
+    )
+    api_key = resolve_provider_config_value(
+        provider_config=provider_config,
+        config_key="azure_openai_api_key",
+        env_names=("DIFY_PLAYER_AZURE_OPENAI_API_KEY", "AZURE_OPENAI_API_KEY"),
+        node=node,
+        required=True,
+    )
+    api_version = resolve_provider_config_value(
+        provider_config=provider_config,
+        config_key="azure_openai_api_version",
+        env_names=("DIFY_PLAYER_AZURE_OPENAI_API_VERSION", "AZURE_OPENAI_API_VERSION"),
+        node=node,
+        required=True,
+    )
 
     messages = render_value(
         node.config["messages"],
@@ -59,13 +78,6 @@ async def run(
     )
 
 
-def _require_env(name: str, *, node: Node) -> str:
-    value = os.environ.get(name)
-    if value:
-        return value
-    raise ValueError(f"llm node {node.label!r} requires environment variable {name}")
-
-
 def _build_request_body(*, node: Node, messages: Any) -> dict[str, Any]:
     if not isinstance(messages, list):
         raise ValueError(f"llm node {node.label!r} config.messages must render to an array")

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/nodes/llm_groq_chat.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import json
-import os
 from typing import Any
 
 import httpx
@@ -19,6 +18,7 @@ from dify_player.nodes.llm_azure_chat import (
     _validate_schema,
     _zero_usage,
 )
+from dify_player.provider_config import ProviderConfig, resolve_provider_config_value
 from dify_player.value_renderer import render_value
 
 _DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
@@ -32,10 +32,24 @@ async def run(
     node_outputs: dict[str, dict[str, Any]],
     resolved_inputs: dict[str, Any],
     http_client: httpx.AsyncClient | None = None,
+    provider_config: ProviderConfig | None = None,
 ) -> dict[str, Any]:
     _ = resolved_inputs
-    api_key = _require_env("GROQ_API_KEY", node=node)
-    base_url = os.environ.get("GROQ_API_BASE_URL", _DEFAULT_BASE_URL)
+    api_key = resolve_provider_config_value(
+        provider_config=provider_config,
+        config_key="groq_api_key",
+        env_names=("DIFY_PLAYER_GROQ_API_KEY", "GROQ_API_KEY"),
+        node=node,
+        required=True,
+    )
+    base_url = resolve_provider_config_value(
+        provider_config=provider_config,
+        config_key="groq_api_base_url",
+        env_names=("DIFY_PLAYER_GROQ_API_BASE_URL", "GROQ_API_BASE_URL"),
+        node=node,
+        required=False,
+        default=_DEFAULT_BASE_URL,
+    )
 
     messages = render_value(
         node.config["messages"],
@@ -67,13 +81,6 @@ async def run(
     )
 
 
-def _require_env(name: str, *, node: Node) -> str:
-    value = os.environ.get(name)
-    if value:
-        return value
-    raise ValueError(f"llm node {node.label!r} requires environment variable {name}")
-
-
 def _build_request_body(*, node: Node, messages: Any) -> dict[str, Any]:
     if not isinstance(messages, list):
         raise ValueError(f"llm node {node.label!r} config.messages must render to an array")

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/plan_loader.py

@@ -390,8 +390,10 @@ def _validate_if_else_config(*, node_id: str, node_name: str | None, config: dic
                 raise PlanValidationError(
                     f"if_else node {node_label!r} config.cases[{case_index}].conditions[{condition_index}] must be an object"
                 )
-            if condition.get("operator") not in {"contains", "empty", "equals"}:
-                raise PlanValidationError(f"if_else node {node_label!r} only supports operator=contains, empty, or equals")
+            if condition.get("operator") not in {"contains", "empty", "equals", "not_empty"}:
+                raise PlanValidationError(
+                    f"if_else node {node_label!r} only supports operator=contains, empty, equals, or not_empty"
+                )
             input_name = condition.get("input_name")
             if not isinstance(input_name, str) or not input_name:
                 raise PlanValidationError(

dify_player-0.3.7/dify_player/provider_config.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any
+
+from dify_player.models import Node
+
+ProviderConfig = Mapping[str, Any]
+
+
+def resolve_provider_config_value(
+    *,
+    provider_config: ProviderConfig | None,
+    config_key: str,
+    env_names: tuple[str, ...],
+    node: Node,
+    required: bool,
+    default: str | None = None,
+) -> str:
+    if provider_config is not None:
+        value = provider_config.get(config_key)
+        if value:
+            if not isinstance(value, str):
+                raise ValueError(f"llm node {node.label!r} provider_config[{config_key!r}] must be a string")
+            return value
+
+    for env_name in env_names:
+        value = os.environ.get(env_name)
+        if value:
+            return value
+
+    if default is not None:
+        return default
+    if required:
+        sources = [f"provider_config[{config_key!r}]"] + [f"environment variable {env_name}" for env_name in env_names]
+        raise ValueError(f"llm node {node.label!r} requires {' or '.join(sources)}")
+    raise ValueError(f"llm node {node.label!r} provider config {config_key!r} is not configured")

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/runtime.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import time
 from copy import deepcopy
 from datetime import datetime, timezone
@@ -26,6 +27,7 @@ from dify_player.input_resolver import resolve_node_inputs
 from dify_player.llm_cache import LLMCacheStore, NullLLMCacheStore, build_llm_cache_key
 from dify_player.models import CompiledLoop, CompiledPlan, Edge, Node, NodeResult, RunResult, RunState, WorkflowError
 from dify_player.nodes import run_node
+from dify_player.provider_config import ProviderConfig
 from dify_player.value_renderer import render_value
 
 
@@ -36,10 +38,12 @@ class WorkflowRuntime:
         *,
         llm_cache_enabled: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> None:
         self.logger = logger
         self.llm_cache_enabled = llm_cache_enabled
         self.llm_cache_store = llm_cache_store if llm_cache_store is not None else NullLLMCacheStore()
+        self.provider_config = provider_config
 
     async def run(
         self,
@@ -455,6 +459,7 @@ class WorkflowRuntime:
             node_outputs=node_outputs,
             resolved_inputs=resolved_inputs,
             http_client=http_client,
+            provider_config=self.provider_config,
         )
 
         if not self._should_use_llm_cache(node=node):
@@ -528,7 +533,8 @@ class WorkflowRuntime:
                     node.config["messages"],
                     {"inputs": workflow_inputs, "nodes": node_outputs},
                     location=f"llm cache key for node {node.label!r} config.messages",
-                )
+                ),
+                "provider_config": _cacheable_provider_config(self.provider_config),
             }
         return build_llm_cache_key(
             node_kind=node.kind,
@@ -772,6 +778,37 @@ def _normalize_workflow_inputs(*, compiled_plan: CompiledPlan, inputs: dict[str,
     return normalized_inputs
 
 
+def _cacheable_provider_config(provider_config: ProviderConfig | None) -> dict[str, Any]:
+    values = {
+        "azure_openai_endpoint": _cacheable_provider_config_value(
+            provider_config=provider_config,
+            config_key="azure_openai_endpoint",
+            env_names=("DIFY_PLAYER_AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_ENDPOINT"),
+        ),
+        "azure_openai_api_version": _cacheable_provider_config_value(
+            provider_config=provider_config,
+            config_key="azure_openai_api_version",
+            env_names=("DIFY_PLAYER_AZURE_OPENAI_API_VERSION", "AZURE_OPENAI_API_VERSION"),
+        ),
+    }
+    return {key: value for key, value in values.items() if value}
+
+
+def _cacheable_provider_config_value(
+    *,
+    provider_config: ProviderConfig | None,
+    config_key: str,
+    env_names: tuple[str, ...],
+) -> Any:
+    if provider_config is not None and provider_config.get(config_key):
+        return provider_config[config_key]
+    for env_name in env_names:
+        value = os.environ.get(env_name)
+        if value:
+            return value
+    return None
+
+
 class _LoopRuntimeError(ValueError):
     def __init__(self, error: WorkflowError) -> None:
         super().__init__(error.message)

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/workflow_engine.py

@@ -9,6 +9,7 @@ from dify_player.event_logger import NullEventLogger, WorkflowLogger
 from dify_player.llm_cache import LLMCacheStore
 from dify_player.models import CompiledPlan, Plan, RunResult
 from dify_player.plan_loader import parse_plan
+from dify_player.provider_config import ProviderConfig
 from dify_player.workflow_executor import WorkflowExecutor
 
 
@@ -26,6 +27,7 @@ class WorkflowEngine:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         effective_logger, owns_logger = _resolve_logger(run_id=run_id, logger=logger)
         try:
@@ -36,6 +38,7 @@ class WorkflowEngine:
                 http_client=http_client,
                 llm_cache=llm_cache,
                 llm_cache_store=llm_cache_store,
+                provider_config=provider_config,
             )
         finally:
             if owns_logger:
@@ -51,6 +54,7 @@ class WorkflowEngine:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         effective_logger, owns_logger = _resolve_logger(run_id=run_id, logger=logger)
         try:
@@ -61,6 +65,7 @@ class WorkflowEngine:
                 http_client=http_client,
                 llm_cache=llm_cache,
                 llm_cache_store=llm_cache_store,
+                provider_config=provider_config,
             )
         finally:
             if owns_logger:
@@ -76,6 +81,7 @@ class WorkflowEngine:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         plan = parse_plan(plan_data)
         return await self.run_plan(
@@ -86,6 +92,7 @@ class WorkflowEngine:
             http_client=http_client,
             llm_cache=llm_cache,
             llm_cache_store=llm_cache_store,
+            provider_config=provider_config,
         )
 
 

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player/workflow_executor.py

@@ -13,6 +13,7 @@ from dify_player.exceptions import PlanValidationError
 from dify_player.llm_cache import LLMCacheStore
 from dify_player.models import CompiledPlan, Plan, RunResult, WorkflowError
 from dify_player.plan_loader import compile_plan, load_input_data, load_plan_definition
+from dify_player.provider_config import ProviderConfig
 from dify_player.runtime import WorkflowRuntime
 
 
@@ -33,11 +34,13 @@ class WorkflowExecutor:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         runtime = WorkflowRuntime(
             logger=logger,
             llm_cache_enabled=llm_cache,
             llm_cache_store=llm_cache_store,
+            provider_config=provider_config,
         )
         return await runtime.run(
             compiled_plan=compiled_plan,
@@ -58,6 +61,7 @@ class WorkflowExecutor:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         try:
             compiled_plan = compile_plan(plan)
@@ -79,6 +83,7 @@ class WorkflowExecutor:
             http_client=http_client,
             llm_cache=llm_cache,
             llm_cache_store=llm_cache_store,
+            provider_config=provider_config,
         )
 
     async def run_plan_path(
@@ -90,6 +95,7 @@ class WorkflowExecutor:
         http_client: httpx.AsyncClient | None = None,
         llm_cache: bool = False,
         llm_cache_store: LLMCacheStore | None = None,
+        provider_config: ProviderConfig | None = None,
     ) -> RunResult:
         run_id = uuid.uuid4().hex
         resolved_log_path = log_path if log_path is not None else build_default_log_path(run_id)
@@ -142,6 +148,7 @@ class WorkflowExecutor:
                 http_client=http_client,
                 llm_cache=llm_cache,
                 llm_cache_store=llm_cache_store,
+                provider_config=provider_config,
             )
 
             if result.status == "failed":

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dify-player
-Version: 0.3.5
+Version: 0.3.7
 Summary: Minimal workflow runner for hand-authored Dify-like plans.
 Requires-Python: >=3.11
 Requires-Dist: Jinja2<4,>=3.1

{dify_player-0.3.5 → dify_player-0.3.7}/dify_player.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ dify_player/input_resolver.py
 dify_player/llm_cache.py
 dify_player/models.py
 dify_player/plan_loader.py
+dify_player/provider_config.py
 dify_player/runtime.py
 dify_player/value_renderer.py
 dify_player/workflow_engine.py

{dify_player-0.3.5 → dify_player-0.3.7}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dify-player"
-version = "0.3.5"
+version = "0.3.7"
 description = "Minimal workflow runner for hand-authored Dify-like plans."
 requires-python = ">=3.11"
 dependencies = [