dify-oapi2 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

dify_oapi/api/knowledge/v1/model/retrieval_model.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 from .knowledge_types import SearchMethod
 from .reranking_mode import RerankingMode
+from .weights import Weights
 
 
 class RetrievalModel(BaseModel):
@@ -13,11 +14,12 @@ class RetrievalModel(BaseModel):
 
     search_method: Optional[SearchMethod] = None
     reranking_enable: Optional[bool] = None
-    reranking_mode: Optional[RerankingMode] = None
+    reranking_mode: Optional[str] = None
+    reranking_model: Optional[RerankingMode] = None
     top_k: Optional[int] = None
     score_threshold_enabled: Optional[bool] = None
     score_threshold: Optional[float] = None
-    weights: Optional[float] = None
+    weights: Optional[Weights] = None
 
     @staticmethod
     def builder() -> "RetrievalModelBuilder":
@@ -41,10 +43,14 @@ class RetrievalModelBuilder:
         self._retrieval_model.reranking_enable = reranking_enable
         return self
 
-    def reranking_mode(self, reranking_mode: RerankingMode) -> "RetrievalModelBuilder":
+    def reranking_mode(self, reranking_mode: str) -> "RetrievalModelBuilder":
         self._retrieval_model.reranking_mode = reranking_mode
         return self
 
+    def reranking_model(self, reranking_model: RerankingMode) -> "RetrievalModelBuilder":
+        self._retrieval_model.reranking_model = reranking_model
+        return self
+
     def top_k(self, top_k: int) -> "RetrievalModelBuilder":
         self._retrieval_model.top_k = top_k
         return self
@@ -57,6 +63,6 @@ class RetrievalModelBuilder:
         self._retrieval_model.score_threshold = score_threshold
         return self
 
-    def weights(self, weights: float) -> "RetrievalModelBuilder":
+    def weights(self, weights: Weights) -> "RetrievalModelBuilder":
         self._retrieval_model.weights = weights
         return self

dify_oapi/api/knowledge/v1/model/update_document_by_file_request.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import json
 from io import BytesIO
 
 from dify_oapi.core.enum import HttpMethod
@@ -50,8 +49,7 @@ class UpdateDocumentByFileRequestBuilder:
 
     def request_body(self, request_body: UpdateDocumentByFileRequestBody) -> UpdateDocumentByFileRequestBuilder:
         self._update_document_by_file_request.request_body = request_body
-        data_dict = request_body.model_dump(exclude_none=True, mode="json")
-        self._update_document_by_file_request.body = {"data": json.dumps(data_dict)}
+        self._update_document_by_file_request.body = request_body.model_dump(exclude_none=True, mode="json")
         return self
 
     def file(self, file: BytesIO, file_name: str | None = None) -> UpdateDocumentByFileRequestBuilder:

dify_oapi/api/knowledge/v1/model/update_document_by_file_request_body.py

@@ -4,22 +4,13 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from .knowledge_types import IndexingTechnique
-from .process_rule import ProcessRule
-from .retrieval_model import RetrievalModel
+from .update_document_by_file_request_body_data import UpdateDocumentByFileRequestBodyData
 
 
 class UpdateDocumentByFileRequestBody(BaseModel):
     """Request body model for update document by file API."""
 
-    name: str | None = None
-    indexing_technique: IndexingTechnique | None = None
-    doc_form: str | None = None
-    doc_language: str | None = None
-    process_rule: ProcessRule | None = None
-    retrieval_model: RetrievalModel | None = None
-    embedding_model: str | None = None
-    embedding_model_provider: str | None = None
+    data: str | None = None
 
     @staticmethod
     def builder() -> UpdateDocumentByFileRequestBodyBuilder:
@@ -35,34 +26,6 @@ class UpdateDocumentByFileRequestBodyBuilder:
     def build(self) -> UpdateDocumentByFileRequestBody:
         return self._update_document_by_file_request_body
 
-    def name(self, name: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.name = name
-        return self
-
-    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.indexing_technique = indexing_technique
-        return self
-
-    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.process_rule = process_rule
-        return self
-
-    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.doc_form = doc_form
-        return self
-
-    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.doc_language = doc_language
-        return self
-
-    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.retrieval_model = retrieval_model
-        return self
-
-    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.embedding_model = embedding_model
-        return self
-
-    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyBuilder:
-        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+    def data(self, data: UpdateDocumentByFileRequestBodyData) -> UpdateDocumentByFileRequestBodyBuilder:
+        self._update_document_by_file_request_body.data = data.model_dump_json(exclude_none=True)
         return self

dify_oapi/api/knowledge/v1/model/update_document_by_file_request_body_data.py

@@ -0,0 +1,68 @@
+"""Update document by file request body model."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from .knowledge_types import IndexingTechnique
+from .process_rule import ProcessRule
+from .retrieval_model import RetrievalModel
+
+
+class UpdateDocumentByFileRequestBodyData(BaseModel):
+    """Request body model for update document by file API."""
+
+    name: str | None = None
+    indexing_technique: IndexingTechnique | None = None
+    doc_form: str | None = None
+    doc_language: str | None = None
+    process_rule: ProcessRule | None = None
+    retrieval_model: RetrievalModel | None = None
+    embedding_model: str | None = None
+    embedding_model_provider: str | None = None
+
+    @staticmethod
+    def builder() -> UpdateDocumentByFileRequestBodyDataBuilder:
+        return UpdateDocumentByFileRequestBodyDataBuilder()
+
+
+class UpdateDocumentByFileRequestBodyDataBuilder:
+    """Builder for UpdateDocumentByFileRequestBodyData."""
+
+    def __init__(self) -> None:
+        self._update_document_by_file_request_body = UpdateDocumentByFileRequestBodyData()
+
+    def build(self) -> UpdateDocumentByFileRequestBodyData:
+        return self._update_document_by_file_request_body
+
+    def name(self, name: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.name = name
+        return self
+
+    def indexing_technique(self, indexing_technique: IndexingTechnique) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.indexing_technique = indexing_technique
+        return self
+
+    def process_rule(self, process_rule: ProcessRule) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.process_rule = process_rule
+        return self
+
+    def doc_form(self, doc_form: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.doc_form = doc_form
+        return self
+
+    def doc_language(self, doc_language: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.doc_language = doc_language
+        return self
+
+    def retrieval_model(self, retrieval_model: RetrievalModel) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.retrieval_model = retrieval_model
+        return self
+
+    def embedding_model(self, embedding_model: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.embedding_model = embedding_model
+        return self
+
+    def embedding_model_provider(self, embedding_model_provider: str) -> UpdateDocumentByFileRequestBodyDataBuilder:
+        self._update_document_by_file_request_body.embedding_model_provider = embedding_model_provider
+        return self

dify_oapi/api/knowledge/v1/model/weights.py

@@ -0,0 +1,27 @@
+"""Weights model for retrieval configuration."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class KeywordSetting(BaseModel):
+    """Keyword search weight settings."""
+
+    keyword_weight: Optional[float] = None
+
+
+class VectorSetting(BaseModel):
+    """Vector search weight settings."""
+
+    vector_weight: Optional[float] = None
+    embedding_model_name: Optional[str] = None
+    embedding_provider_name: Optional[str] = None
+
+
+class Weights(BaseModel):
+    """Weights configuration for hybrid search."""
+
+    weight_type: Optional[str] = None
+    keyword_setting: Optional[KeywordSetting] = None
+    vector_setting: Optional[VectorSetting] = None

dify_oapi/api/knowledge/v1/resource/__init__.py

@@ -1,8 +0,0 @@
-from .chunk import Chunk
-from .dataset import Dataset
-from .document import Document
-from .model import Model
-from .segment import Segment
-from .tag import Tag
-
-__all__ = ["Chunk", "Dataset", "Document", "Model", "Segment", "Tag"]

dify_oapi/api/workflow/v1/model/chunk_workflow_event.py

@@ -0,0 +1,74 @@
+"""Chunk workflow event for streaming mode.
+
+This module defines the base structure for workflow streaming events
+and specific event data models.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import EventType
+
+
+class ChunkWorkflowEvent(BaseModel):
+    """Base streaming event structure for workflow execution."""
+
+    event: EventType
+    task_id: Optional[str] = None
+    workflow_run_id: Optional[str] = None
+    data: Optional[dict[str, Any]] = None
+    message_id: Optional[str] = None
+    audio: Optional[str] = None
+    created_at: Optional[int] = None
+
+    @staticmethod
+    def builder() -> "ChunkWorkflowEventBuilder":
+        """Create a new ChunkWorkflowEvent builder."""
+        return ChunkWorkflowEventBuilder()
+
+
+class ChunkWorkflowEventBuilder:
+    """Builder for ChunkWorkflowEvent."""
+
+    def __init__(self):
+        self._chunk_workflow_event = ChunkWorkflowEvent(event="ping")
+
+    def build(self) -> ChunkWorkflowEvent:
+        """Build the ChunkWorkflowEvent instance."""
+        return self._chunk_workflow_event
+
+    def event(self, event: EventType) -> "ChunkWorkflowEventBuilder":
+        """Set the event type."""
+        self._chunk_workflow_event.event = event
+        return self
+
+    def task_id(self, task_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the task ID."""
+        self._chunk_workflow_event.task_id = task_id
+        return self
+
+    def workflow_run_id(self, workflow_run_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the workflow run ID."""
+        self._chunk_workflow_event.workflow_run_id = workflow_run_id
+        return self
+
+    def data(self, data: dict[str, Any]) -> "ChunkWorkflowEventBuilder":
+        """Set the event data."""
+        self._chunk_workflow_event.data = data
+        return self
+
+    def message_id(self, message_id: str) -> "ChunkWorkflowEventBuilder":
+        """Set the message ID (for TTS events)."""
+        self._chunk_workflow_event.message_id = message_id
+        return self
+
+    def audio(self, audio: str) -> "ChunkWorkflowEventBuilder":
+        """Set the audio data (for TTS events)."""
+        self._chunk_workflow_event.audio = audio
+        return self
+
+    def created_at(self, created_at: int) -> "ChunkWorkflowEventBuilder":
+        """Set the creation timestamp."""
+        self._chunk_workflow_event.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/input_file_object_workflow.py

@@ -0,0 +1,76 @@
+"""Input file object for workflow multimodal support.
+
+This module defines the InputFileObjectWorkflow model for handling file inputs
+in workflow execution with proper validation rules.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, model_validator
+
+from .workflow_types import FileType, TransferMethod
+
+
+class InputFileObjectWorkflow(BaseModel):
+    """File input object for workflow execution.
+
+    Supports both remote URL and local file upload methods with validation rules:
+    - When transfer_method is "remote_url": url is required, upload_file_id must be None
+    - When transfer_method is "local_file": upload_file_id is required, url must be None
+    """
+
+    type: FileType
+    transfer_method: TransferMethod
+    url: Optional[str] = None
+    upload_file_id: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_transfer_method_fields(self):
+        """Validate that the correct fields are provided based on transfer_method."""
+        if self.transfer_method == "remote_url":
+            if not self.url:
+                raise ValueError("url is required when transfer_method is 'remote_url'")
+            if self.upload_file_id is not None:
+                raise ValueError("upload_file_id must be None when transfer_method is 'remote_url'")
+        elif self.transfer_method == "local_file":
+            if not self.upload_file_id:
+                raise ValueError("upload_file_id is required when transfer_method is 'local_file'")
+            if self.url is not None:
+                raise ValueError("url must be None when transfer_method is 'local_file'")
+        return self
+
+    @staticmethod
+    def builder() -> "InputFileObjectWorkflowBuilder":
+        """Create a new InputFileObjectWorkflow builder."""
+        return InputFileObjectWorkflowBuilder()
+
+
+class InputFileObjectWorkflowBuilder:
+    """Builder for InputFileObjectWorkflow."""
+
+    def __init__(self):
+        self._input_file_object_workflow = InputFileObjectWorkflow(type="document", transfer_method="local_file")
+
+    def build(self) -> InputFileObjectWorkflow:
+        """Build the InputFileObjectWorkflow instance."""
+        return self._input_file_object_workflow
+
+    def type(self, file_type: FileType) -> "InputFileObjectWorkflowBuilder":
+        """Set the file type."""
+        self._input_file_object_workflow.type = file_type
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> "InputFileObjectWorkflowBuilder":
+        """Set the transfer method."""
+        self._input_file_object_workflow.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the remote URL (for remote_url transfer method)."""
+        self._input_file_object_workflow.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> "InputFileObjectWorkflowBuilder":
+        """Set the upload file ID (for local_file transfer method)."""
+        self._input_file_object_workflow.upload_file_id = upload_file_id
+        return self

dify_oapi/api/workflow/v1/model/node_finished_data.py

@@ -0,0 +1,118 @@
+"""Node finished event data model.
+
+This module defines the data structure for node_finished streaming events.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .execution_metadata import ExecutionMetadata
+from .workflow_types import NodeStatus, NodeType
+
+
+class NodeFinishedData(BaseModel):
+    """Data structure for node_finished streaming event."""
+
+    id: str
+    node_id: str
+    node_type: NodeType
+    title: str
+    index: int
+    predecessor_node_id: Optional[str] = None
+    inputs: Optional[dict[str, Any]] = None
+    process_data: Optional[dict[str, Any]] = None
+    outputs: Optional[dict[str, Any]] = None
+    status: NodeStatus
+    error: Optional[str] = None
+    elapsed_time: Optional[float] = None
+    execution_metadata: Optional[ExecutionMetadata] = None
+    created_at: int
+
+    @staticmethod
+    def builder() -> "NodeFinishedDataBuilder":
+        """Create a new NodeFinishedData builder."""
+        return NodeFinishedDataBuilder()
+
+
+class NodeFinishedDataBuilder:
+    """Builder for NodeFinishedData."""
+
+    def __init__(self):
+        self._node_finished_data = NodeFinishedData(
+            id="", node_id="", node_type="start", title="", index=0, status="succeeded", created_at=0
+        )
+
+    def build(self) -> NodeFinishedData:
+        """Build the NodeFinishedData instance."""
+        return self._node_finished_data
+
+    def id(self, id: str) -> "NodeFinishedDataBuilder":
+        """Set the node execution ID."""
+        self._node_finished_data.id = id
+        return self
+
+    def node_id(self, node_id: str) -> "NodeFinishedDataBuilder":
+        """Set the node ID."""
+        self._node_finished_data.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> "NodeFinishedDataBuilder":
+        """Set the node type."""
+        self._node_finished_data.node_type = node_type
+        return self
+
+    def title(self, title: str) -> "NodeFinishedDataBuilder":
+        """Set the node title."""
+        self._node_finished_data.title = title
+        return self
+
+    def index(self, index: int) -> "NodeFinishedDataBuilder":
+        """Set the node index."""
+        self._node_finished_data.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> "NodeFinishedDataBuilder":
+        """Set the predecessor node ID."""
+        self._node_finished_data.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the node inputs."""
+        self._node_finished_data.inputs = inputs
+        return self
+
+    def process_data(self, process_data: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the process data."""
+        self._node_finished_data.process_data = process_data
+        return self
+
+    def outputs(self, outputs: dict[str, Any]) -> "NodeFinishedDataBuilder":
+        """Set the node outputs."""
+        self._node_finished_data.outputs = outputs
+        return self
+
+    def status(self, status: NodeStatus) -> "NodeFinishedDataBuilder":
+        """Set the node status."""
+        self._node_finished_data.status = status
+        return self
+
+    def error(self, error: str) -> "NodeFinishedDataBuilder":
+        """Set the error message."""
+        self._node_finished_data.error = error
+        return self
+
+    def elapsed_time(self, elapsed_time: float) -> "NodeFinishedDataBuilder":
+        """Set the elapsed time."""
+        self._node_finished_data.elapsed_time = elapsed_time
+        return self
+
+    def execution_metadata(self, execution_metadata: ExecutionMetadata) -> "NodeFinishedDataBuilder":
+        """Set the execution metadata."""
+        self._node_finished_data.execution_metadata = execution_metadata
+        return self
+
+    def created_at(self, created_at: int) -> "NodeFinishedDataBuilder":
+        """Set the creation timestamp."""
+        self._node_finished_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/node_started_data.py

@@ -0,0 +1,81 @@
+"""Node started event data model.
+
+This module defines the data structure for node_started streaming events.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .workflow_types import NodeType
+
+
+class NodeStartedData(BaseModel):
+    """Data structure for node_started streaming event."""
+
+    id: str
+    node_id: str
+    node_type: NodeType
+    title: str
+    index: int
+    predecessor_node_id: Optional[str] = None
+    inputs: dict[str, Any]
+    created_at: int
+
+    @staticmethod
+    def builder() -> "NodeStartedDataBuilder":
+        """Create a new NodeStartedData builder."""
+        return NodeStartedDataBuilder()
+
+
+class NodeStartedDataBuilder:
+    """Builder for NodeStartedData."""
+
+    def __init__(self):
+        self._node_started_data = NodeStartedData(
+            id="", node_id="", node_type="start", title="", index=0, inputs={}, created_at=0
+        )
+
+    def build(self) -> NodeStartedData:
+        """Build the NodeStartedData instance."""
+        return self._node_started_data
+
+    def id(self, id: str) -> "NodeStartedDataBuilder":
+        """Set the node execution ID."""
+        self._node_started_data.id = id
+        return self
+
+    def node_id(self, node_id: str) -> "NodeStartedDataBuilder":
+        """Set the node ID."""
+        self._node_started_data.node_id = node_id
+        return self
+
+    def node_type(self, node_type: NodeType) -> "NodeStartedDataBuilder":
+        """Set the node type."""
+        self._node_started_data.node_type = node_type
+        return self
+
+    def title(self, title: str) -> "NodeStartedDataBuilder":
+        """Set the node title."""
+        self._node_started_data.title = title
+        return self
+
+    def index(self, index: int) -> "NodeStartedDataBuilder":
+        """Set the node index."""
+        self._node_started_data.index = index
+        return self
+
+    def predecessor_node_id(self, predecessor_node_id: str) -> "NodeStartedDataBuilder":
+        """Set the predecessor node ID."""
+        self._node_started_data.predecessor_node_id = predecessor_node_id
+        return self
+
+    def inputs(self, inputs: dict[str, Any]) -> "NodeStartedDataBuilder":
+        """Set the node inputs."""
+        self._node_started_data.inputs = inputs
+        return self
+
+    def created_at(self, created_at: int) -> "NodeStartedDataBuilder":
+        """Set the creation timestamp."""
+        self._node_started_data.created_at = created_at
+        return self

dify_oapi/api/workflow/v1/model/ping_data.py

@@ -0,0 +1,28 @@
+"""Ping event data model.
+
+This module defines the data structure for ping streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class PingData(BaseModel):
+    """Data structure for ping streaming event (empty data)."""
+
+    pass
+
+    @staticmethod
+    def builder() -> "PingDataBuilder":
+        """Create a new PingData builder."""
+        return PingDataBuilder()
+
+
+class PingDataBuilder:
+    """Builder for PingData."""
+
+    def __init__(self):
+        self._ping_data = PingData()
+
+    def build(self) -> PingData:
+        """Build the PingData instance."""
+        return self._ping_data

dify_oapi/api/workflow/v1/model/run_workflow_request_body.py

@@ -9,7 +9,7 @@ from .workflow_types import ResponseMode
 
 class RunWorkflowRequestBody(BaseModel):
     inputs: WorkflowInputs | None = None
-    response_mode: ResponseMode | None = None
+    response_mode: ResponseMode | None = "streaming"
     user: str | None = None
     files: list[WorkflowFileInfo] | None = None
     trace_id: str | None = None

dify_oapi/api/workflow/v1/model/text_chunk_data.py

@@ -0,0 +1,39 @@
+"""Text chunk event data model.
+
+This module defines the data structure for text_chunk streaming events.
+"""
+
+from pydantic import BaseModel
+
+
+class TextChunkData(BaseModel):
+    """Data structure for text_chunk streaming event."""
+
+    text: str
+    from_variable_selector: list[str]
+
+    @staticmethod
+    def builder() -> "TextChunkDataBuilder":
+        """Create a new TextChunkData builder."""
+        return TextChunkDataBuilder()
+
+
+class TextChunkDataBuilder:
+    """Builder for TextChunkData."""
+
+    def __init__(self):
+        self._text_chunk_data = TextChunkData(text="", from_variable_selector=[])
+
+    def build(self) -> TextChunkData:
+        """Build the TextChunkData instance."""
+        return self._text_chunk_data
+
+    def text(self, text: str) -> "TextChunkDataBuilder":
+        """Set the text chunk."""
+        self._text_chunk_data.text = text
+        return self
+
+    def from_variable_selector(self, from_variable_selector: list[str]) -> "TextChunkDataBuilder":
+        """Set the variable selector path."""
+        self._text_chunk_data.from_variable_selector = from_variable_selector
+        return self