dify-oapi2 0.1.0__py3-none-any.whl

dify_oapi/api/workflow/v1/resource/workflow.py

@@ -0,0 +1,102 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Literal, overload
+
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_workflow_log_request import GetWorkflowLogRequest
+from ..model.get_workflow_log_response import GetWorkflowLogResponse
+from ..model.get_workflow_result_request import GetWorkflowResultRequest
+from ..model.get_workflow_result_response import GetWorkflowResultResponse
+from ..model.run_workflow_request import RunWorkflowRequest
+from ..model.run_workflow_response import RunWorkflowResponse
+from ..model.stop_workflow_request import StopWorkflowRequest
+from ..model.stop_workflow_response import StopWorkflowResponse
+
+
+class Workflow:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+
+    @overload
+    def run(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None,
+        stream: Literal[True],
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def run(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None,
+        stream: Literal[False],
+    ) -> RunWorkflowResponse: ...
+
+    @overload
+    def run(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
+
+    def run(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return Transport.execute(self.config, request, option=option, stream=True)
+        else:
+            return Transport.execute(self.config, request, unmarshal_as=RunWorkflowResponse, option=option)
+
+    @overload
+    async def arun(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None,
+        stream: Literal[True],
+    ) -> AsyncGenerator[bytes, None]: ...
+
+    @overload
+    async def arun(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None,
+        stream: Literal[False],
+    ) -> RunWorkflowResponse: ...
+
+    @overload
+    async def arun(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
+
+    async def arun(
+        self,
+        request: RunWorkflowRequest,
+        option: RequestOption | None = None,
+        stream: bool = False,
+    ):
+        if stream:
+            return await ATransport.aexecute(self.config, request, option=option, stream=True)
+        else:
+            return await ATransport.aexecute(self.config, request, unmarshal_as=RunWorkflowResponse, option=option)
+
+    def stop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+
+    async def astop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+
+    def result(
+        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
+    ) -> GetWorkflowResultResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+
+    async def aresult(
+        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
+    ) -> GetWorkflowResultResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+
+    def log(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)
+
+    async def alog(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)

dify_oapi/api/workflow/v1/version.py

@@ -0,0 +1,8 @@
+from dify_oapi.core.model.config import Config
+
+from .resource import Workflow
+
+
+class V1:
+    def __init__(self, config: Config):
+        self.workflow: Workflow = Workflow(config)

dify_oapi/client.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from .api.chat.service import ChatService
+from .api.completion.service import CompletionService
+from .api.dify.service import DifyService
+from .api.knowledge_base.service import KnowledgeBaseService
+from .api.workflow.service import WorkflowService
+from .core.enum import LogLevel
+from .core.http.transport import Transport
+from .core.log import logger
+from .core.model.base_request import BaseRequest
+from .core.model.config import Config
+
+
+class Client:
+    def __init__(self):
+        self._config: Config | None = None
+        self._chat: ChatService | None = None
+        self._completion: CompletionService | None = None
+        self._dify: DifyService | None = None
+        self._workflow: WorkflowService | None = None
+        self._knowledge_base: KnowledgeBaseService | None = None
+
+    @property
+    def chat(self) -> ChatService:
+        if self._chat is None:
+            raise RuntimeError("Chat service has not been initialized")
+        return self._chat
+
+    @property
+    def completion(self) -> CompletionService:
+        if self._completion is None:
+            raise RuntimeError("Completion service has not been initialized")
+        return self._completion
+
+    @property
+    def dify(self) -> DifyService:
+        if self._dify is None:
+            raise RuntimeError("Dify service has not been initialized")
+        return self._dify
+
+    @property
+    def workflow(self) -> WorkflowService:
+        if self._workflow is None:
+            raise RuntimeError("Workflow service has not been initialized")
+        return self._workflow
+
+    @property
+    def knowledge_base(self) -> KnowledgeBaseService:
+        if self._knowledge_base is None:
+            raise RuntimeError("Knowledge base service has not been initialized")
+        return self._knowledge_base
+
+    def request(self, request: BaseRequest):
+        if self._config is None:
+            raise RuntimeError("Config is not set")
+        resp = Transport.execute(self._config, request)
+        return resp
+
+    @staticmethod
+    def builder() -> ClientBuilder:
+        return ClientBuilder()
+
+
+class ClientBuilder:
+    def __init__(self) -> None:
+        self._config = Config()
+
+    def domain(self, domain: str) -> ClientBuilder:
+        self._config.domain = domain
+        return self
+
+    def log_level(self, level: LogLevel) -> ClientBuilder:
+        self._config.log_level = level
+        return self
+
+    def max_retry_count(self, count: int) -> ClientBuilder:
+        self._config.max_retry_count = count
+        return self
+
+    def build(self) -> Client:
+        client: Client = Client()
+        client._config = self._config
+
+        # Initialize logger
+        self._init_logger()
+
+        # Initialize services
+        client._chat = ChatService(self._config)
+        client._completion = CompletionService(self._config)
+        client._dify = DifyService(self._config)
+        client._workflow = WorkflowService(self._config)
+        client._knowledge_base = KnowledgeBaseService(self._config)
+        return client
+
+    def _init_logger(self):
+        logger.setLevel(int(self._config.log_level.value))

dify_oapi/core/const.py

@@ -0,0 +1,15 @@
+# # Info
+# VERSION = "1.2.6"
+
+# Header
+USER_AGENT = "User-Agent"
+AUTHORIZATION = "Authorization"
+CONTENT_TYPE = "Content-Type"
+
+# Content-Type
+APPLICATION_JSON = "application/json"
+
+UTF_8 = "UTF-8"
+
+
+SLEEP_BASE_TIME = 0.1

dify_oapi/core/enum.py

@@ -0,0 +1,21 @@
+from enum import Enum, auto
+
+
+class HttpMethod(Enum):
+    GET = auto()
+    HEAD = auto()
+    POST = auto()
+    PUT = auto()
+    PATCH = auto()
+    DELETE = auto()
+    CONNECT = auto()
+    OPTIONS = auto()
+    TRACE = auto()
+
+
+class LogLevel(Enum):
+    DEBUG = 10
+    INFO = 20
+    WARNING = 30
+    ERROR = 40
+    CRITICAL = 50

dify_oapi/core/http/transport/__init__.py

@@ -0,0 +1,4 @@
+from .async_transport import ATransport
+from .sync_transport import Transport
+
+__all__ = ["Transport", "ATransport"]

dify_oapi/core/http/transport/_misc.py

@@ -0,0 +1,145 @@
+from dify_oapi.core.const import APPLICATION_JSON, AUTHORIZATION, SLEEP_BASE_TIME, UTF_8
+from dify_oapi.core.json import JSON
+from dify_oapi.core.log import logger
+from dify_oapi.core.misc import HiddenText
+from dify_oapi.core.model.base_request import BaseRequest
+from dify_oapi.core.model.raw_response import RawResponse
+from dify_oapi.core.model.request_option import RequestOption
+from dify_oapi.core.type import T
+
+
+def _build_url(domain: str | None, uri: str | None, paths: dict[str, str] | None) -> str:
+    if not domain:
+        raise RuntimeError("domain is required")
+    if not uri:
+        raise RuntimeError("uri is required")
+
+    # Replace path parameters
+    for key, value in (paths or {}).items():
+        uri = uri.replace(f":{key}", value)
+
+    # Normalize URL joining
+    return f"{domain.rstrip('/')}{uri}" if not uri.startswith("/") else f"{domain.rstrip('/')}{uri}"
+
+
+def _build_header(request: BaseRequest, option: RequestOption) -> dict[str, str]:
+    headers = request.headers.copy()
+
+    # Merge option headers
+    if option.headers:
+        headers.update(option.headers)
+
+    # Add authorization header
+    if option.api_key:
+        hidden_text = HiddenText(f"Bearer {option.api_key}", redacted="****")
+        headers[AUTHORIZATION] = hidden_text.secret
+
+    return headers
+
+
+def _merge_dicts(*dicts: dict | None) -> dict:
+    """Merge multiple dictionaries, ignoring None values."""
+    result: dict = {}
+    for d in filter(None, dicts):
+        result.update(d)
+    return result
+
+
+def _create_no_content_response(unmarshal_as: type[T]) -> T:
+    """Create response for 204 No Content status."""
+    try:
+        if hasattr(unmarshal_as, "__annotations__") and "result" in unmarshal_as.__annotations__:
+            return unmarshal_as(result="success")
+        return unmarshal_as()
+    except Exception:
+        resp = unmarshal_as.__new__(unmarshal_as)
+        if hasattr(resp, "result"):
+            try:
+                object.__setattr__(resp, "result", "success")
+            except Exception:
+                pass
+        return resp
+
+
+def _handle_json_response(content: str, unmarshal_as: type[T]) -> T:
+    """Handle JSON response content."""
+    import json
+
+    parsed_json = json.loads(content)
+
+    if isinstance(parsed_json, list):
+        return _handle_array_response(parsed_json, unmarshal_as)
+    elif isinstance(parsed_json, dict):
+        return JSON.unmarshal(content, unmarshal_as)
+    else:
+        return _handle_primitive_response(parsed_json, unmarshal_as)
+
+
+def _handle_array_response(data: list, unmarshal_as: type[T]) -> T:
+    """Handle array JSON responses."""
+    if hasattr(unmarshal_as, "__annotations__") and "data" in unmarshal_as.__annotations__:
+        return unmarshal_as(data=data)
+    return unmarshal_as(data=data)
+
+
+def _handle_primitive_response(value, unmarshal_as: type[T]) -> T:
+    """Handle primitive JSON responses."""
+    if not hasattr(unmarshal_as, "__annotations__"):
+        return unmarshal_as()
+
+    annotations = unmarshal_as.__annotations__
+    if "result" in annotations:
+        return unmarshal_as(result=str(value))
+    elif "data" in annotations:
+        return unmarshal_as(data=value)
+    else:
+        return unmarshal_as()
+
+
+def _set_raw_response(resp: T, raw_resp: RawResponse) -> T:
+    """Set raw response on the response object."""
+    try:
+        object.__setattr__(resp, "raw", raw_resp)
+    except Exception:
+        try:
+            resp.raw = raw_resp
+        except Exception:
+            if hasattr(resp, "model_copy"):
+                resp = resp.model_copy(update={"raw": raw_resp})
+    return resp
+
+
+def _unmarshaller(raw_resp: RawResponse, unmarshal_as: type[T]) -> T:
+    """Unmarshal raw response to typed response object."""
+    if not raw_resp.status_code:
+        raise RuntimeError("status_code is required")
+    if raw_resp.content is None:
+        raise RuntimeError("content is required")
+
+    # Handle 204 No Content
+    if raw_resp.status_code == 204:
+        resp = _create_no_content_response(unmarshal_as)
+    # Handle JSON content
+    elif raw_resp.content_type and raw_resp.content_type.startswith(APPLICATION_JSON):
+        content = str(raw_resp.content, UTF_8)
+        if content:
+            try:
+                resp = _handle_json_response(content, unmarshal_as)
+            except Exception as e:
+                logger.error(f"Failed to unmarshal to {unmarshal_as} from {content}")
+                raise e
+        else:
+            resp = unmarshal_as()
+    else:
+        # Fallback for non-JSON content
+        try:
+            resp = unmarshal_as()
+        except Exception:
+            resp = unmarshal_as.__new__(unmarshal_as)
+
+    return _set_raw_response(resp, raw_resp)
+
+
+def _get_sleep_time(retry_count: int) -> float:
+    """Calculate exponential backoff sleep time for retries."""
+    return float(SLEEP_BASE_TIME * (2 ** (retry_count - 1)))

dify_oapi/core/http/transport/async_transport.py

@@ -0,0 +1,217 @@
+import asyncio
+import json
+from collections.abc import AsyncGenerator, Coroutine
+from typing import Literal, overload
+
+import httpx
+
+from dify_oapi.core.enum import HttpMethod
+from dify_oapi.core.json import JSON
+from dify_oapi.core.log import logger
+from dify_oapi.core.model.base_request import BaseRequest
+from dify_oapi.core.model.base_response import BaseResponse
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.raw_response import RawResponse
+from dify_oapi.core.model.request_option import RequestOption
+from dify_oapi.core.type import T
+
+from ._misc import _build_header, _build_url, _get_sleep_time, _merge_dicts, _unmarshaller
+
+
+def _format_log_details(
+    method: str, url: str, headers: dict, queries: list[tuple[str, str]] | dict, body_data: dict | None
+) -> str:
+    """Format log details"""
+    details = [f"{method} {url}"]
+    if headers:
+        details.append(f"headers: {JSON.marshal(headers)}")
+    if queries:
+        queries_dict = dict(queries) if isinstance(queries, list) else queries
+        details.append(f"params: {JSON.marshal(queries_dict)}")
+    if body_data:
+        details.append(f"body: {JSON.marshal(body_data)}")
+    return ", ".join(details)
+
+
+async def _handle_async_stream_error(response: httpx.Response) -> bytes:
+    """Handle async streaming response errors"""
+    try:
+        error_detail = await response.aread()
+        error_message = error_detail.decode("utf-8", errors="ignore").strip()
+    except Exception:
+        error_message = f"Error response with status code {response.status_code}"
+    logger.warning(f"Streaming request failed: {response.status_code}, detail: {error_message}")
+    return f"data: [ERROR] {error_message}\n\n".encode()
+
+
+async def _async_stream_generator(
+    conf: Config,
+    req: BaseRequest,
+    *,
+    url: str,
+    headers: dict[str, str],
+    json_: dict | None,
+    data: dict | None,
+    files: dict | None,
+    http_method: HttpMethod,
+):
+    method_name = http_method.name
+    body_data = _merge_dicts(json_, files, data)
+
+    for retry in range(conf.max_retry_count + 1):
+        if retry > 0:
+            sleep_time = _get_sleep_time(retry)
+            logger.info(f"in-request: sleep {sleep_time}s")
+            await asyncio.sleep(sleep_time)
+
+        try:
+            async with (
+                httpx.AsyncClient() as client,
+                client.stream(
+                    method_name,
+                    url,
+                    headers=headers,
+                    params=tuple(req.queries),
+                    json=json_,
+                    data=data,
+                    files=files,
+                    timeout=conf.timeout,
+                ) as response,
+            ):
+                logger.debug(
+                    f"{_format_log_details(method_name, url, headers, req.queries, body_data)}, stream response"
+                )
+
+                if response.status_code != 200:
+                    yield await _handle_async_stream_error(response)
+                    return
+
+                try:
+                    async for chunk in response.aiter_bytes():
+                        yield chunk
+                except Exception as e:
+                    logger.exception("Streaming failed during chunk reading")
+                    yield f"data: [ERROR] Stream interrupted: {str(e)}\n\n".encode()
+                return
+
+        except httpx.RequestError as e:
+            err_msg = f"{e.__class__.__name__}: {e!r}"
+            log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
+
+            if retry < conf.max_retry_count:
+                logger.info(f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}")
+                continue
+            logger.info(
+                f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+            )
+            raise
+
+
+class ATransport:
+    @staticmethod
+    @overload
+    def aexecute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        stream: Literal[True],
+        option: RequestOption | None,
+    ) -> Coroutine[None, None, AsyncGenerator[bytes, None]]: ...
+
+    @staticmethod
+    @overload
+    def aexecute(conf: Config, req: BaseRequest) -> Coroutine[None, None, BaseResponse]: ...
+
+    @staticmethod
+    @overload
+    def aexecute(
+        conf: Config, req: BaseRequest, *, option: RequestOption | None
+    ) -> Coroutine[None, None, BaseResponse]: ...
+
+    @staticmethod
+    @overload
+    def aexecute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        unmarshal_as: type[T],
+        option: RequestOption | None,
+    ) -> Coroutine[None, None, T]: ...
+
+    @staticmethod
+    async def aexecute(
+        conf: Config,
+        req: BaseRequest,
+        *,
+        stream: bool = False,
+        unmarshal_as: type[T] | type[BaseResponse] | None = None,
+        option: RequestOption | None = None,
+    ):
+        unmarshal_as = unmarshal_as or BaseResponse
+        option = option or RequestOption()
+
+        if req.http_method is None:
+            raise RuntimeError("HTTP method is required")
+
+        url = _build_url(conf.domain, req.uri, req.paths)
+        headers = _build_header(req, option)
+
+        # Prepare request body
+        json_, files, data = None, None, None
+        if req.files:
+            files = req.files
+            if req.body is not None:
+                data = json.loads(JSON.marshal(req.body))
+        elif req.body is not None:
+            json_ = json.loads(JSON.marshal(req.body))
+
+        if stream:
+            return _async_stream_generator(
+                conf, req, url=url, headers=headers, json_=json_, data=data, files=files, http_method=req.http_method
+            )
+
+        method_name = req.http_method.name
+        body_data = _merge_dicts(json_, files, data)
+
+        async with httpx.AsyncClient() as client:
+            for retry in range(conf.max_retry_count + 1):
+                if retry > 0:
+                    sleep_time = _get_sleep_time(retry)
+                    logger.info(f"in-request: sleep {sleep_time}s")
+                    await asyncio.sleep(sleep_time)
+
+                try:
+                    response = await client.request(
+                        method_name,
+                        url,
+                        headers=headers,
+                        params=tuple(req.queries),
+                        json=json_,
+                        data=data,
+                        files=files,
+                        timeout=conf.timeout,
+                    )
+                    break
+                except httpx.RequestError as e:
+                    err_msg = f"{e.__class__.__name__}: {e!r}"
+                    log_details = _format_log_details(method_name, url, headers, req.queries, body_data)
+
+                    if retry < conf.max_retry_count:
+                        logger.info(
+                            f"in-request: retrying ({retry + 1}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                        )
+                        continue
+                    logger.info(
+                        f"in-request: request failed, retried ({retry}/{conf.max_retry_count}) {log_details}, exp: {err_msg}"
+                    )
+                    raise
+
+            logger.debug(
+                f"{_format_log_details(method_name, url, headers, req.queries, body_data)} {response.status_code}"
+            )
+
+            raw_resp = RawResponse()
+            raw_resp.status_code = response.status_code
+            raw_resp.headers = dict(response.headers)
+            raw_resp.content = response.content
+            return _unmarshaller(raw_resp, unmarshal_as)