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

dify_oapi/api/completion/v1/model/completion/completion_inputs.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 from pydantic import BaseModel
 
 
@@ -7,22 +9,44 @@ class CompletionInputs(BaseModel):
     """
     Inputs for completion application containing variables defined in the App.
     Text generation applications require at least the query field.
+    Additional custom variables can be added as needed.
     """
 
-    query: str | None = None  # User input text content (required for completion apps)
+    query: str  # Required: User input text content
+
+    # Allow additional fields for custom variables
+    model_config = {"extra": "allow"}
 
     @staticmethod
     def builder() -> CompletionInputsBuilder:
         return CompletionInputsBuilder()
 
+    def with_variables(self, **kwargs: Any) -> CompletionInputs:
+        result: CompletionInputs = self.model_copy(update=kwargs)
+        return result
+
 
 class CompletionInputsBuilder:
     def __init__(self):
-        self._completion_inputs = CompletionInputs()
+        self._inputs: CompletionInputs | None = None
 
     def build(self) -> CompletionInputs:
-        return self._completion_inputs
+        if self._inputs is None:
+            raise ValueError("query field is required for CompletionInputs")
+        return self._inputs
 
     def query(self, query: str) -> CompletionInputsBuilder:
-        self._completion_inputs.query = query
+        self._inputs = CompletionInputs(query=query)
+        return self
+
+    def add_variable(self, key: str, value: Any) -> CompletionInputsBuilder:
+        if self._inputs is None:
+            raise ValueError("Must set query first")
+        self._inputs = self._inputs.with_variables(**{key: value})
+        return self
+
+    def variables(self, **kwargs: Any) -> CompletionInputsBuilder:
+        if self._inputs is None:
+            raise ValueError("Must set query first")
+        self._inputs = self._inputs.with_variables(**kwargs)
         return self

dify_oapi/api/completion/v1/model/completion/completion_types.py

@@ -12,7 +12,7 @@ FileType = Literal["image"]
 TransferMethod = Literal["remote_url", "local_file"]
 
 # Feedback rating types
-FeedbackRating = Literal["like", "dislike", "null"]
+FeedbackRating = Literal["like", "dislike"]
 
 # Annotation action types
 AnnotationAction = Literal["enable", "disable"]
@@ -25,3 +25,21 @@ AppMode = Literal["completion"]
 
 # Job status types
 JobStatus = Literal["waiting", "running", "completed", "failed"]
+
+# Event types for streaming
+EventType = Literal["message", "message_end", "tts_message", "tts_message_end", "message_replace", "error", "ping"]
+
+# User input form types
+UserInputFormType = Literal["text-input", "paragraph", "select"]
+
+# Audio format types
+AudioFormat = Literal["mp3", "wav"]
+
+# Image format types
+ImageFormat = Literal["png", "jpg", "jpeg", "webp", "gif"]
+
+# Currency types (common currencies)
+CurrencyType = Literal["USD", "EUR", "CNY", "JPY", "GBP"]
+
+# Language codes (common language codes)
+LanguageCode = Literal["en-US", "zh-CN", "ja-JP", "ko-KR", "fr-FR", "de-DE", "es-ES", "pt-BR", "ru-RU"]

dify_oapi/api/completion/v1/model/completion/input_file_object.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, field_validator
+
+from .completion_types import FileType, TransferMethod
+
+
+class InputFileObject(BaseModel):
+    """File input object for multimodal understanding."""
+
+    type: FileType
+    transfer_method: TransferMethod
+    url: str | None = None
+    upload_file_id: str | None = None
+
+    @field_validator("url", "upload_file_id")
+    @classmethod
+    def validate_transfer_method_fields(cls, v, info):
+        """Validate that the correct field is provided based on transfer_method."""
+        if info.data.get("transfer_method") == "remote_url":
+            if info.field_name == "url" and v is None:
+                raise ValueError("url is required when transfer_method is remote_url")
+            if info.field_name == "upload_file_id" and v is not None:
+                raise ValueError("upload_file_id must not be provided when transfer_method is remote_url")
+        elif info.data.get("transfer_method") == "local_file":
+            if info.field_name == "upload_file_id" and v is None:
+                raise ValueError("upload_file_id is required when transfer_method is local_file")
+            if info.field_name == "url" and v is not None:
+                raise ValueError("url must not be provided when transfer_method is local_file")
+        return v
+
+    @staticmethod
+    def builder() -> InputFileObjectBuilder:
+        return InputFileObjectBuilder()
+
+
+class InputFileObjectBuilder:
+    def __init__(self):
+        self._file_object = InputFileObject(type="image", transfer_method="remote_url")
+
+    def build(self) -> InputFileObject:
+        return self._file_object
+
+    def type(self, type_: FileType) -> InputFileObjectBuilder:
+        self._file_object.type = type_
+        return self
+
+    def transfer_method(self, transfer_method: TransferMethod) -> InputFileObjectBuilder:
+        self._file_object.transfer_method = transfer_method
+        return self
+
+    def url(self, url: str) -> InputFileObjectBuilder:
+        self._file_object.url = url
+        return self
+
+    def upload_file_id(self, upload_file_id: str) -> InputFileObjectBuilder:
+        self._file_object.upload_file_id = upload_file_id
+        return self

dify_oapi/api/completion/v1/model/completion/send_message_request_body.py

@@ -1,51 +1,33 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
+from typing import Any
 
-from .completion_inputs import CompletionInputs
-from .completion_types import FileType, ResponseMode, TransferMethod
-
-
-class FileInfo(BaseModel):
-    type: FileType | None = None
-    transfer_method: TransferMethod | None = None
-    url: str | None = None
-    upload_file_id: str | None = None
-
-    @staticmethod
-    def builder() -> FileInfoBuilder:
-        return FileInfoBuilder()
-
-
-class FileInfoBuilder:
-    def __init__(self):
-        self._file_info = FileInfo()
-
-    def build(self) -> FileInfo:
-        return self._file_info
-
-    def type(self, type_: FileType) -> FileInfoBuilder:
-        self._file_info.type = type_
-        return self
+from pydantic import BaseModel, field_validator
 
-    def transfer_method(self, transfer_method: TransferMethod) -> FileInfoBuilder:
-        self._file_info.transfer_method = transfer_method
-        return self
-
-    def url(self, url: str) -> FileInfoBuilder:
-        self._file_info.url = url
-        return self
-
-    def upload_file_id(self, upload_file_id: str) -> FileInfoBuilder:
-        self._file_info.upload_file_id = upload_file_id
-        return self
+from .completion_inputs import CompletionInputs
+from .completion_types import ResponseMode
+from .input_file_object import InputFileObject
 
 
 class SendMessageRequestBody(BaseModel):
-    inputs: CompletionInputs | None = None
-    response_mode: ResponseMode | None = None
+    """Request body for sending completion messages."""
+
+    inputs: dict[str, Any]  # Variable values defined by the App, must include 'query'
+    response_mode: ResponseMode | None = "streaming"
     user: str | None = None
-    files: list[FileInfo] | None = None
+    files: list[InputFileObject] | None = None
+
+    @field_validator("inputs")
+    @classmethod
+    def validate_inputs(cls, v):
+        """Validate that inputs contains the required 'query' field."""
+        if not isinstance(v, dict):
+            raise ValueError("inputs must be a dictionary")
+        if "query" not in v:
+            raise ValueError('inputs must contain a "query" field')
+        if not isinstance(v["query"], str):
+            raise ValueError("query field must be a string")
+        return v
 
     @staticmethod
     def builder() -> SendMessageRequestBodyBuilder:
@@ -54,13 +36,27 @@ class SendMessageRequestBody(BaseModel):
 
 class SendMessageRequestBodyBuilder:
     def __init__(self):
-        self._send_message_request_body = SendMessageRequestBody()
+        self._send_message_request_body = SendMessageRequestBody(inputs={"query": ""})
 
     def build(self) -> SendMessageRequestBody:
         return self._send_message_request_body
 
-    def inputs(self, inputs: CompletionInputs) -> SendMessageRequestBodyBuilder:
-        self._send_message_request_body.inputs = inputs
+    def inputs(self, inputs: CompletionInputs | dict[str, Any]) -> SendMessageRequestBodyBuilder:
+        """Set inputs from CompletionInputs object or dictionary."""
+        if isinstance(inputs, CompletionInputs):
+            self._send_message_request_body.inputs = inputs.model_dump()
+        else:
+            self._send_message_request_body.inputs = inputs
+        return self
+
+    def query(self, query: str) -> SendMessageRequestBodyBuilder:
+        """Set the query field directly."""
+        self._send_message_request_body.inputs["query"] = query
+        return self
+
+    def add_variable(self, key: str, value: str) -> SendMessageRequestBodyBuilder:
+        """Add a custom variable to inputs."""
+        self._send_message_request_body.inputs[key] = value
         return self
 
     def response_mode(self, response_mode: ResponseMode) -> SendMessageRequestBodyBuilder:
@@ -71,6 +67,6 @@ class SendMessageRequestBodyBuilder:
         self._send_message_request_body.user = user
         return self
 
-    def files(self, files: list[FileInfo]) -> SendMessageRequestBodyBuilder:
+    def files(self, files: list[InputFileObject]) -> SendMessageRequestBodyBuilder:
         self._send_message_request_body.files = files
         return self

dify_oapi/api/completion/v1/model/completion/usage.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
+from .completion_types import CurrencyType
+
 
 class Usage(BaseModel):
     prompt_tokens: int | None = None
@@ -14,7 +16,7 @@ class Usage(BaseModel):
     completion_price: str | None = None
     total_tokens: int | None = None
     total_price: str | None = None
-    currency: str | None = None
+    currency: CurrencyType | None = None
     latency: float | None = None
 
     @staticmethod
@@ -69,7 +71,7 @@ class UsageBuilder:
         self._usage.total_price = total_price
         return self
 
-    def currency(self, currency: str) -> UsageBuilder:
+    def currency(self, currency: CurrencyType) -> UsageBuilder:
         self._usage.currency = currency
         return self
 

dify_oapi/api/completion/v1/model/info/feature_config.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class SuggestedQuestionsAfterAnswerConfig(BaseModel):
+    """Configuration for suggested questions after answer feature."""
+
+    enabled: bool
+
+    @staticmethod
+    def builder() -> SuggestedQuestionsAfterAnswerConfigBuilder:
+        return SuggestedQuestionsAfterAnswerConfigBuilder()
+
+
+class SuggestedQuestionsAfterAnswerConfigBuilder:
+    def __init__(self):
+        self._config = SuggestedQuestionsAfterAnswerConfig(enabled=False)
+
+    def build(self) -> SuggestedQuestionsAfterAnswerConfig:
+        return self._config
+
+    def enabled(self, enabled: bool) -> SuggestedQuestionsAfterAnswerConfigBuilder:
+        self._config.enabled = enabled
+        return self
+
+
+class SpeechToTextConfig(BaseModel):
+    """Configuration for speech to text feature."""
+
+    enabled: bool
+
+    @staticmethod
+    def builder() -> SpeechToTextConfigBuilder:
+        return SpeechToTextConfigBuilder()
+
+
+class SpeechToTextConfigBuilder:
+    def __init__(self):
+        self._config = SpeechToTextConfig(enabled=False)
+
+    def build(self) -> SpeechToTextConfig:
+        return self._config
+
+    def enabled(self, enabled: bool) -> SpeechToTextConfigBuilder:
+        self._config.enabled = enabled
+        return self
+
+
+class RetrieverResourceConfig(BaseModel):
+    """Configuration for retriever resource (citation and attribution) feature."""
+
+    enabled: bool
+
+    @staticmethod
+    def builder() -> RetrieverResourceConfigBuilder:
+        return RetrieverResourceConfigBuilder()
+
+
+class RetrieverResourceConfigBuilder:
+    def __init__(self):
+        self._config = RetrieverResourceConfig(enabled=False)
+
+    def build(self) -> RetrieverResourceConfig:
+        return self._config
+
+    def enabled(self, enabled: bool) -> RetrieverResourceConfigBuilder:
+        self._config.enabled = enabled
+        return self
+
+
+class AnnotationReplyConfig(BaseModel):
+    """Configuration for annotation reply feature."""
+
+    enabled: bool
+
+    @staticmethod
+    def builder() -> AnnotationReplyConfigBuilder:
+        return AnnotationReplyConfigBuilder()
+
+
+class AnnotationReplyConfigBuilder:
+    def __init__(self):
+        self._config = AnnotationReplyConfig(enabled=False)
+
+    def build(self) -> AnnotationReplyConfig:
+        return self._config
+
+    def enabled(self, enabled: bool) -> AnnotationReplyConfigBuilder:
+        self._config.enabled = enabled
+        return self

dify_oapi/api/completion/v1/model/info/parameters_info.py

@@ -2,6 +2,12 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
+from .feature_config import (
+    AnnotationReplyConfig,
+    RetrieverResourceConfig,
+    SpeechToTextConfig,
+    SuggestedQuestionsAfterAnswerConfig,
+)
 from .file_upload_config import FileUploadConfig
 from .system_parameters import SystemParameters
 from .user_input_form import UserInputForm
@@ -10,10 +16,10 @@ from .user_input_form import UserInputForm
 class ParametersInfo(BaseModel):
     opening_statement: str | None = None
     suggested_questions: list[str] | None = None
-    suggested_questions_after_answer: dict | None = None
-    speech_to_text: dict | None = None
-    retriever_resource: dict | None = None
-    annotation_reply: dict | None = None
+    suggested_questions_after_answer: SuggestedQuestionsAfterAnswerConfig | None = None
+    speech_to_text: SpeechToTextConfig | None = None
+    retriever_resource: RetrieverResourceConfig | None = None
+    annotation_reply: AnnotationReplyConfig | None = None
     user_input_form: list[UserInputForm] | None = None
     file_upload: FileUploadConfig | None = None
     system_parameters: SystemParameters | None = None
@@ -38,19 +44,21 @@ class ParametersInfoBuilder:
         self._parameters_info.suggested_questions = suggested_questions
         return self
 
-    def suggested_questions_after_answer(self, suggested_questions_after_answer: dict) -> ParametersInfoBuilder:
+    def suggested_questions_after_answer(
+        self, suggested_questions_after_answer: SuggestedQuestionsAfterAnswerConfig
+    ) -> ParametersInfoBuilder:
         self._parameters_info.suggested_questions_after_answer = suggested_questions_after_answer
         return self
 
-    def speech_to_text(self, speech_to_text: dict) -> ParametersInfoBuilder:
+    def speech_to_text(self, speech_to_text: SpeechToTextConfig) -> ParametersInfoBuilder:
         self._parameters_info.speech_to_text = speech_to_text
         return self
 
-    def retriever_resource(self, retriever_resource: dict) -> ParametersInfoBuilder:
+    def retriever_resource(self, retriever_resource: RetrieverResourceConfig) -> ParametersInfoBuilder:
         self._parameters_info.retriever_resource = retriever_resource
         return self
 
-    def annotation_reply(self, annotation_reply: dict) -> ParametersInfoBuilder:
+    def annotation_reply(self, annotation_reply: AnnotationReplyConfig) -> ParametersInfoBuilder:
         self._parameters_info.annotation_reply = annotation_reply
         return self
 

dify_oapi/api/completion/v1/model/info/site_info.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from ..completion.completion_types import IconType
+from ..completion.completion_types import IconType, LanguageCode
 
 
 class SiteInfo(BaseModel):
@@ -17,7 +17,7 @@ class SiteInfo(BaseModel):
     copyright: str | None = None
     privacy_policy: str | None = None
     custom_disclaimer: str | None = None
-    default_language: str | None = None
+    default_language: LanguageCode | None = None
     show_workflow_steps: bool | None = None
     use_icon_as_answer_icon: bool | None = None
 
@@ -77,7 +77,7 @@ class SiteInfoBuilder:
         self._site_info.custom_disclaimer = custom_disclaimer
         return self
 
-    def default_language(self, default_language: str) -> SiteInfoBuilder:
+    def default_language(self, default_language: LanguageCode) -> SiteInfoBuilder:
         self._site_info.default_language = default_language
         return self
 

dify_oapi/api/completion/v1/model/info/user_input_form.py

@@ -1,19 +1,60 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
-class UserInputForm(BaseModel):
-    label: str | None = None
-    variable: str | None = None
-    required: bool | None = None
+class TextInputControl(BaseModel):
+    """Text input control configuration."""
+
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+
+class ParagraphControl(BaseModel):
+    """Paragraph (multi-line text) control configuration."""
+
+    label: str
+    variable: str
+    required: bool
     default: str | None = None
-    options: list[str] | None = None
+
+
+class SelectControl(BaseModel):
+    """Select (dropdown) control configuration."""
+
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+    options: list[str]
+
+
+class UserInputForm(BaseModel):
+    """User input form configuration supporting different control types."""
+
+    # Use discriminated union to support different form control types
+    text_input: TextInputControl | None = Field(default=None, alias="text-input")
+    paragraph: ParagraphControl | None = None
+    select: SelectControl | None = None
 
     @staticmethod
     def builder() -> UserInputFormBuilder:
         return UserInputFormBuilder()
 
+    @staticmethod
+    def text_input_builder() -> TextInputFormBuilder:
+        return TextInputFormBuilder()
+
+    @staticmethod
+    def paragraph_builder() -> ParagraphFormBuilder:
+        return ParagraphFormBuilder()
+
+    @staticmethod
+    def select_builder() -> SelectFormBuilder:
+        return SelectFormBuilder()
+
 
 class UserInputFormBuilder:
     def __init__(self):
@@ -22,22 +63,96 @@ class UserInputFormBuilder:
     def build(self) -> UserInputForm:
         return self._user_input_form
 
-    def label(self, label: str) -> UserInputFormBuilder:
-        self._user_input_form.label = label
+    def text_input(self, text_input: TextInputControl) -> UserInputFormBuilder:
+        self._user_input_form.text_input = text_input
+        return self
+
+    def paragraph(self, paragraph: ParagraphControl) -> UserInputFormBuilder:
+        self._user_input_form.paragraph = paragraph
+        return self
+
+    def select(self, select: SelectControl) -> UserInputFormBuilder:
+        self._user_input_form.select = select
+        return self
+
+
+class TextInputFormBuilder:
+    def __init__(self):
+        self._control = TextInputControl(label="", variable="", required=False)
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.text_input = self._control
+        return form
+
+    def label(self, label: str) -> TextInputFormBuilder:
+        self._control.label = label
+        return self
+
+    def variable(self, variable: str) -> TextInputFormBuilder:
+        self._control.variable = variable
+        return self
+
+    def required(self, required: bool) -> TextInputFormBuilder:
+        self._control.required = required
+        return self
+
+    def default(self, default: str) -> TextInputFormBuilder:
+        self._control.default = default
+        return self
+
+
+class ParagraphFormBuilder:
+    def __init__(self):
+        self._control = ParagraphControl(label="", variable="", required=False)
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.paragraph = self._control
+        return form
+
+    def label(self, label: str) -> ParagraphFormBuilder:
+        self._control.label = label
+        return self
+
+    def variable(self, variable: str) -> ParagraphFormBuilder:
+        self._control.variable = variable
+        return self
+
+    def required(self, required: bool) -> ParagraphFormBuilder:
+        self._control.required = required
+        return self
+
+    def default(self, default: str) -> ParagraphFormBuilder:
+        self._control.default = default
+        return self
+
+
+class SelectFormBuilder:
+    def __init__(self):
+        self._control = SelectControl(label="", variable="", required=False, options=[])
+
+    def build(self) -> UserInputForm:
+        form = UserInputForm()
+        form.select = self._control
+        return form
+
+    def label(self, label: str) -> SelectFormBuilder:
+        self._control.label = label
         return self
 
-    def variable(self, variable: str) -> UserInputFormBuilder:
-        self._user_input_form.variable = variable
+    def variable(self, variable: str) -> SelectFormBuilder:
+        self._control.variable = variable
         return self
 
-    def required(self, required: bool) -> UserInputFormBuilder:
-        self._user_input_form.required = required
+    def required(self, required: bool) -> SelectFormBuilder:
+        self._control.required = required
         return self
 
-    def default(self, default: str) -> UserInputFormBuilder:
-        self._user_input_form.default = default
+    def default(self, default: str) -> SelectFormBuilder:
+        self._control.default = default
         return self
 
-    def options(self, options: list[str]) -> UserInputFormBuilder:
-        self._user_input_form.options = options
+    def options(self, options: list[str]) -> SelectFormBuilder:
+        self._control.options = options
         return self

dify_oapi/api/knowledge/service.py

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