dify-oapi2 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

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

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+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.info.get_info_request import GetInfoRequest
+from ..model.info.get_info_response import GetInfoResponse
+from ..model.info.get_parameters_request import GetParametersRequest
+from ..model.info.get_parameters_response import GetParametersResponse
+from ..model.info.get_site_request import GetSiteRequest
+from ..model.info.get_site_response import GetSiteResponse
+
+
+class Info:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def get_info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        """Get application basic information.
+
+        Args:
+            request: The get info request
+            request_option: Request options including API key
+
+        Returns:
+            GetInfoResponse with application information
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    async def aget_info(self, request: GetInfoRequest, request_option: RequestOption) -> GetInfoResponse:
+        """Get application basic information asynchronously.
+
+        Args:
+            request: The get info request
+            request_option: Request options including API key
+
+        Returns:
+            GetInfoResponse with application information
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetInfoResponse, option=request_option)
+
+    def get_parameters(self, request: GetParametersRequest, request_option: RequestOption) -> GetParametersResponse:
+        """Get application parameters.
+
+        Args:
+            request: The get parameters request
+            request_option: Request options including API key
+
+        Returns:
+            GetParametersResponse with application parameters
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetParametersResponse, option=request_option)
+
+    async def aget_parameters(
+        self, request: GetParametersRequest, request_option: RequestOption
+    ) -> GetParametersResponse:
+        """Get application parameters asynchronously.
+
+        Args:
+            request: The get parameters request
+            request_option: Request options including API key
+
+        Returns:
+            GetParametersResponse with application parameters
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetParametersResponse, option=request_option
+        )
+
+    def get_site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
+        """Get WebApp settings.
+
+        Args:
+            request: The get site request
+            request_option: Request options including API key
+
+        Returns:
+            GetSiteResponse with WebApp settings
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)
+
+    async def aget_site(self, request: GetSiteRequest, request_option: RequestOption) -> GetSiteResponse:
+        """Get WebApp settings asynchronously.
+
+        Args:
+            request: The get site request
+            request_option: Request options including API key
+
+        Returns:
+            GetSiteResponse with WebApp settings
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=GetSiteResponse, option=request_option)

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

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+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.log.get_workflow_logs_request import GetWorkflowLogsRequest
+from ..model.log.get_workflow_logs_response import GetWorkflowLogsResponse
+
+
+class Log:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def get_workflow_logs(
+        self, request: GetWorkflowLogsRequest, request_option: RequestOption
+    ) -> GetWorkflowLogsResponse:
+        """Get workflow execution logs.
+
+        Args:
+            request: The get workflow logs request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowLogsResponse with workflow logs
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option)
+
+    async def aget_workflow_logs(
+        self, request: GetWorkflowLogsRequest, request_option: RequestOption
+    ) -> GetWorkflowLogsResponse:
+        """Get workflow execution logs asynchronously.
+
+        Args:
+            request: The get workflow logs request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowLogsResponse with workflow logs
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetWorkflowLogsResponse, option=request_option
+        )

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

@@ -5,98 +5,216 @@ 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
+from ..model.workflow.get_workflow_run_detail_request import GetWorkflowRunDetailRequest
+from ..model.workflow.get_workflow_run_detail_response import GetWorkflowRunDetailResponse
+from ..model.workflow.run_specific_workflow_request import RunSpecificWorkflowRequest
+from ..model.workflow.run_specific_workflow_response import RunSpecificWorkflowResponse
+from ..model.workflow.run_workflow_request import RunWorkflowRequest
+from ..model.workflow.run_workflow_response import RunWorkflowResponse
+from ..model.workflow.stop_workflow_request import StopWorkflowRequest
+from ..model.workflow.stop_workflow_response import StopWorkflowResponse
 
 
 class Workflow:
     def __init__(self, config: Config) -> None:
-        self.config: Config = config
+        self.config = config
 
     @overload
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> Generator[bytes, None, None]: ...
 
     @overload
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
+        request_option: RequestOption,
+        stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    @overload
-    def run(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
-
-    def run(
+    def run_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None = None,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> RunWorkflowResponse | Generator[bytes, None, None]:
+        """Execute workflow.
+
+        Args:
+            request: The run workflow request
+            request_option: Request options including API key
+            stream: Whether to use streaming mode
+
+        Returns:
+            RunWorkflowResponse for blocking mode or Generator[bytes, None, None] for streaming mode
+        """
         if stream:
-            return Transport.execute(self.config, request, option=option, stream=True)
-        else:
-            return Transport.execute(self.config, request, unmarshal_as=RunWorkflowResponse, option=option)
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=RunWorkflowResponse, option=request_option)
 
     @overload
-    async def arun(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
+        request_option: RequestOption,
         stream: Literal[True],
     ) -> AsyncGenerator[bytes, None]: ...
 
     @overload
-    async def arun(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None,
-        stream: Literal[False],
+        request_option: RequestOption,
+        stream: Literal[False] = False,
     ) -> RunWorkflowResponse: ...
 
-    @overload
-    async def arun(self, request: RunWorkflowRequest, option: RequestOption | None) -> RunWorkflowResponse: ...
-
-    async def arun(
+    async def arun_workflow(
         self,
         request: RunWorkflowRequest,
-        option: RequestOption | None = None,
+        request_option: RequestOption,
         stream: bool = False,
-    ):
+    ) -> RunWorkflowResponse | AsyncGenerator[bytes, None]:
+        """Execute workflow asynchronously.
+
+        Args:
+            request: The run workflow request
+            request_option: Request options including API key
+            stream: Whether to use streaming mode
+
+        Returns:
+            RunWorkflowResponse for blocking mode or AsyncGenerator[bytes, None] for streaming mode
+        """
         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)
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(self.config, request, unmarshal_as=RunWorkflowResponse, option=request_option)
+
+    @overload
+    def run_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def run_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> RunSpecificWorkflowResponse: ...
 
-    def stop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
-        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+    def run_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> RunSpecificWorkflowResponse | Generator[bytes, None, None]:
+        """Execute specific version workflow.
 
-    async def astop(self, request: StopWorkflowRequest, option: RequestOption | None = None) -> StopWorkflowResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=option)
+        Args:
+            request: The run specific workflow request
+            request_option: Request options including API key
+            stream: Whether to use streaming mode
 
-    def result(
-        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
-    ) -> GetWorkflowResultResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+        Returns:
+            RunSpecificWorkflowResponse for blocking mode or Generator[bytes, None, None] for streaming mode
+        """
+        if stream:
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=RunSpecificWorkflowResponse, option=request_option)
 
-    async def aresult(
-        self, request: GetWorkflowResultRequest, option: RequestOption | None = None
-    ) -> GetWorkflowResultResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowResultResponse, option=option)
+    @overload
+    async def arun_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
+    ) -> AsyncGenerator[bytes, None]: ...
 
-    def log(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
-        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)
+    @overload
+    async def arun_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> RunSpecificWorkflowResponse: ...
 
-    async def alog(self, request: GetWorkflowLogRequest, option: RequestOption | None = None) -> GetWorkflowLogResponse:
-        return await ATransport.aexecute(self.config, request, unmarshal_as=GetWorkflowLogResponse, option=option)
+    async def arun_specific_workflow(
+        self,
+        request: RunSpecificWorkflowRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> RunSpecificWorkflowResponse | AsyncGenerator[bytes, None]:
+        """Execute specific version workflow asynchronously.
+
+        Args:
+            request: The run specific workflow request
+            request_option: Request options including API key
+            stream: Whether to use streaming mode
+
+        Returns:
+            RunSpecificWorkflowResponse for blocking mode or AsyncGenerator[bytes, None] for streaming mode
+        """
+        if stream:
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=RunSpecificWorkflowResponse, option=request_option
+        )
+
+    def get_workflow_run_detail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
+        """Get workflow execution details.
+
+        Args:
+            request: The get workflow run detail request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowRunDetailResponse with workflow execution details
+        """
+        return Transport.execute(self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option)
+
+    async def aget_workflow_run_detail(
+        self, request: GetWorkflowRunDetailRequest, request_option: RequestOption
+    ) -> GetWorkflowRunDetailResponse:
+        """Get workflow execution details asynchronously.
+
+        Args:
+            request: The get workflow run detail request
+            request_option: Request options including API key
+
+        Returns:
+            GetWorkflowRunDetailResponse with workflow execution details
+        """
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetWorkflowRunDetailResponse, option=request_option
+        )
+
+    def stop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        """Stop workflow execution.
+
+        Args:
+            request: The stop workflow request
+            request_option: Request options including API key
+
+        Returns:
+            StopWorkflowResponse with stop result
+        """
+        return Transport.execute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)
+
+    async def astop_workflow(self, request: StopWorkflowRequest, request_option: RequestOption) -> StopWorkflowResponse:
+        """Stop workflow execution asynchronously.
+
+        Args:
+            request: The stop workflow request
+            request_option: Request options including API key
+
+        Returns:
+            StopWorkflowResponse with stop result
+        """
+        return await ATransport.aexecute(self.config, request, unmarshal_as=StopWorkflowResponse, option=request_option)

dify_oapi/api/workflow/v1/version.py

@@ -1,8 +1,14 @@
 from dify_oapi.core.model.config import Config
 
-from .resource import Workflow
+from .resource.file import File
+from .resource.info import Info
+from .resource.log import Log
+from .resource.workflow import Workflow
 
 
 class V1:
     def __init__(self, config: Config):
         self.workflow: Workflow = Workflow(config)
+        self.file: File = File(config)
+        self.log: Log = Log(config)
+        self.info: Info = Info(config)

dify_oapi/core/http/transport/_misc.py

@@ -48,8 +48,15 @@ def _merge_dicts(*dicts: dict | None) -> dict:
 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")
+        # Check if the model has a 'result' field in its annotations
+        annotations = getattr(unmarshal_as, "__annotations__", {})
+        if "result" in annotations:
+            # Only pass result if the specific model supports it
+            try:
+                return unmarshal_as(result="success")  # type: ignore
+            except TypeError:
+                # Fallback if constructor doesn't accept result
+                pass
         return unmarshal_as()
     except Exception:
         resp = unmarshal_as.__new__(unmarshal_as)
@@ -77,23 +84,56 @@ def _handle_json_response(content: str, unmarshal_as: type[T]) -> T:
 
 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)
+    try:
+        # Check if the model has a 'data' field in its annotations
+        annotations = getattr(unmarshal_as, "__annotations__", {})
+        if "data" in annotations:
+            try:
+                return unmarshal_as(data=data)  # type: ignore
+            except TypeError:
+                # Fallback if constructor doesn't accept data
+                pass
+        return unmarshal_as()
+    except Exception:
+        resp = unmarshal_as.__new__(unmarshal_as)
+        if hasattr(resp, "data"):
+            try:
+                object.__setattr__(resp, "data", data)
+            except Exception:
+                pass
+        return resp
 
 
 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:
+    try:
+        annotations = getattr(unmarshal_as, "__annotations__", {})
+        if "result" in annotations:
+            try:
+                return unmarshal_as(result=str(value))  # type: ignore
+            except TypeError:
+                # Fallback if constructor doesn't accept result
+                pass
+        elif "data" in annotations:
+            try:
+                return unmarshal_as(data=value)  # type: ignore
+            except TypeError:
+                # Fallback if constructor doesn't accept data
+                pass
         return unmarshal_as()
+    except Exception:
+        resp = unmarshal_as.__new__(unmarshal_as)
+        if hasattr(resp, "result"):
+            try:
+                object.__setattr__(resp, "result", str(value))
+            except Exception:
+                pass
+        elif hasattr(resp, "data"):
+            try:
+                object.__setattr__(resp, "data", value)
+            except Exception:
+                pass
+        return resp
 
 
 def _set_raw_response(resp: T, raw_resp: RawResponse) -> T:

{dify_oapi2-0.1.1.dist-info → dify_oapi2-0.3.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: dify-oapi2
-Version: 0.1.1
+Version: 0.3.0
 Summary: A package for interacting with the Dify Service-API
 License: MIT
 Keywords: dify,nlp,ai,language-processing
 Author: Oscaner Miao
-Author-email: oscaner1997@163.com
+Author-email: oscaner1997@gmail.com
 Requires-Python: >=3.10
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -122,10 +122,13 @@ asyncio.run(async_chat())
 - Conversation and message history management
 - Streaming and blocking response modes
 
-### Completion API
-- Text generation and completion
-- Custom input parameters
-- Streaming support
+### Completion API (15 APIs)
+- **Message Processing**: Send messages and control responses
+- **Annotation Management**: Create, update, and manage annotations
+- **Audio Processing**: Text-to-audio conversion
+- **Feedback System**: Collect and analyze user feedback
+- **File Upload**: Support for document and media files
+- **Application Info**: Configuration and metadata retrieval
 
 ### Knowledge Base API (39 APIs)
 - **Dataset Management**: CRUD operations for datasets
@@ -261,6 +264,7 @@ dify-oapi/
 ## 📖 Documentation
 
 - [**Project Overview**](./docs/overview.md) - Architecture and technical details
+- [**Completion APIs**](./docs/completion/apis.md) - Complete completion API documentation
 - [**Knowledge Base APIs**](./docs/datasets/apis.md) - Complete dataset API documentation
 - [**Examples**](./examples/README.md) - Usage examples and patterns