chore: docstring not match the function parameter (#17162)

api/configs/feature/hosted_service/__init__.py

 from typing import Optional
 
-from pydantic import Field, NonNegativeInt, computed_field
+from pydantic import Field, NonNegativeInt
 from pydantic_settings import BaseSettings
 
 

api/configs/remote_settings_sources/__init__.py

-from typing import Optional
-
 from pydantic import Field
 
 from .apollo import ApolloSettingsSourceInfo

api/controllers/service_api/dataset/dataset.py

         Deletes a dataset given its ID.
 
         Args:
+            _: ignore
             dataset_id (UUID): The ID of the dataset to be deleted.
 
         Returns:

api/core/app/app_config/easy_ui_based_app/model_config/converter.py

         """
         Convert app model config dict to entity.
         :param app_config: app config
-        :param skip_check: skip check
         :raises ProviderTokenNotInitError: provider token not init error
         :return: app orchestration config entity
         """

api/core/app/apps/advanced_chat/app_generator.py

         :param user: account or end user
         :param args: request args
         :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         """
         if not args.get("query"):
             raise ValueError("query is required")
 
         :param app_model: App
         :param workflow: Workflow
+        :param node_id: the node id
         :param user: account or end user
         :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is streamed
         """
         if not node_id:
             raise ValueError("node_id is required")
 
         :param app_model: App
         :param workflow: Workflow
+        :param node_id: the node id
         :param user: account or end user
         :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         """
         if not node_id:
             raise ValueError("node_id is required")

api/core/app/apps/agent_chat/app_generator.py

         :param user: account or end user
         :param args: request args
         :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         """
         if not streaming:
             raise ValueError("Agent Chat App does not support blocking mode")

api/core/app/apps/base_app_runner.py

         :param files: files
         :param query: query
         :param memory: memory
+        :param image_detail_config: the image quality config
         :return:
         """
         # get prompt without memory and context

api/core/app/apps/chat/app_generator.py

         :param user: account or end user
         :param args: request args
         :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         """
         if not args.get("query"):
             raise ValueError("query is required")

api/core/app/apps/completion/app_generator.py

         :param user: account or end user
         :param args: request args
         :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         """
         query = args["query"]
         if not isinstance(query, str):

api/core/app/apps/workflow/app_generator.py

         :param user: account or end user
         :param application_generate_entity: application generate entity
         :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is stream
         :param workflow_thread_pool_id: workflow thread pool id
         """
         # init queue manager
 
         :param app_model: App
         :param workflow: Workflow
+        :param node_id: the node id
         :param user: account or end user
         :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is streamed
         """
         if not node_id:
             raise ValueError("node_id is required")
 
         :param app_model: App
         :param workflow: Workflow
+        :param node_id: the node id
         :param user: account or end user
         :param args: request args
-        :param invoke_from: invoke from source
-        :param stream: is stream
+        :param streaming: is streamed
         """
         if not node_id:
             raise ValueError("node_id is required")

api/core/app/apps/workflow/app_runner.py

     def run(self) -> None:
         """
         Run application
-        :param application_generate_entity: application generate entity
-        :param queue_manager: application queue manager
-        :return:
         """
         app_config = self.application_generate_entity.app_config
         app_config = cast(WorkflowAppConfig, app_config)

api/core/app/task_pipeline/message_cycle_manage.py

     def _generate_conversation_name(self, *, conversation_id: str, query: str) -> Optional[Thread]:
         """
         Generate conversation name.
-        :param conversation: conversation
+        :param conversation_id: conversation id
         :param query: query
         :return: thread
         """

api/core/app/task_pipeline/workflow_cycle_manage.py

     ) -> WorkflowRun:
         """
         Workflow run success
-        :param workflow_run: workflow run
+        :param workflow_run_id: workflow run id
         :param start_at: start time
         :param total_tokens: total tokens
         :param total_steps: total steps
     ) -> WorkflowRun:
         """
         Workflow run failed
-        :param workflow_run: workflow run
+        :param workflow_run_id: workflow run id
         :param start_at: start time
         :param total_tokens: total tokens
         :param total_steps: total steps

api/core/file/upload_file_parser.py

         """
         get signed url from upload file
 
-        :param upload_file: UploadFile object
+        :param upload_file_id: the id of UploadFile object
         :return:
         """
         base_url = dify_config.FILES_URL

api/core/helper/code_executor/code_executor.py

         """
         Execute code
         :param language: code language
+        :param preload: the preload script
         :param code: code
         :return:
         """

api/core/helper/position_helper.py

     """
     Pin the items in the pin list to the beginning of the position map.
     Overall logic: exclude > include > pin
-    :param position_map: the position map to be sorted and filtered
+    :param original_position_map: the position map to be sorted and filtered
     :param pin_list: the list of pins to be put at the beginning
     :return: the sorted position map
     """

api/core/helper/tool_parameter_cache.py

             return None
 
     def set(self, parameters: dict) -> None:
-        """
-        Cache model provider credentials.
-
-        :param credentials: provider credentials
-        :return:
-        """
+        """Cache model provider credentials."""
         redis_client.setex(self.cache_key, 86400, json.dumps(parameters))
 
     def delete(self) -> None:

api/core/model_runtime/model_providers/__base/tts_model.py

         :param credentials: model credentials
         :param voice: model timbre
         :param content_text: text content to be translated
-        :param streaming: output is streaming
         :param user: unique user id
         :return: translated audio file
         """

api/core/rag/datasource/vdb/opengauss/opengauss.py

         Search the nearest neighbors to a vector.
 
         :param query_vector: The input vector to search for similar items.
-        :param top_k: The number of nearest neighbors to return, default is 5.
         :return: List of Documents that are nearest to the query vector.
         """
         top_k = kwargs.get("top_k", 4)

api/core/rag/datasource/vdb/oracle/oraclevector.py

         Search the nearest neighbors to a vector.
 
         :param query_vector: The input vector to search for similar items.
-        :param top_k: The number of nearest neighbors to return, default is 5.
         :return: List of Documents that are nearest to the query vector.
         """
         top_k = kwargs.get("top_k", 4)

api/core/rag/datasource/vdb/pgvector/pgvector.py

         Search the nearest neighbors to a vector.
 
         :param query_vector: The input vector to search for similar items.
-        :param top_k: The number of nearest neighbors to return, default is 5.
         :return: List of Documents that are nearest to the query vector.
         """
         top_k = kwargs.get("top_k", 4)

api/core/rag/datasource/vdb/tidb_on_qdrant/tidb_service.py

         :param iam_url: The URL of the TiDB Cloud IAM API (required).
         :param public_key: The public key for the API (required).
         :param private_key: The private key for the API (required).
-        :param display_name: The user-friendly display name of the cluster (required).
         :param region: The region where the cluster will be created (required).
 
         :return: The response from the API.
     ):
         """
         Update the status of a new TiDB Serverless cluster.
+        :param tidb_serverless_list: The TiDB serverless list (required).
         :param project_id: The project ID of the TiDB Cloud project (required).
         :param api_url: The URL of the TiDB Cloud API (required).
         :param iam_url: The URL of the TiDB Cloud IAM API (required).
         :param public_key: The public key for the API (required).
         :param private_key: The private key for the API (required).
-        :param display_name: The user-friendly display name of the cluster (required).
-        :param region: The region where the cluster will be created (required).
 
         :return: The response from the API.
         """
     ) -> list[dict]:
         """
         Creates a new TiDB Serverless cluster.
+        :param batch_size: The batch size (required).
         :param project_id: The project ID of the TiDB Cloud project (required).
         :param api_url: The URL of the TiDB Cloud API (required).
         :param iam_url: The URL of the TiDB Cloud IAM API (required).
         :param public_key: The public key for the API (required).
         :param private_key: The private key for the API (required).
-        :param display_name: The user-friendly display name of the cluster (required).
         :param region: The region where the cluster will be created (required).
 
         :return: The response from the API.

api/core/rag/datasource/vdb/weaviate/weaviate_vector.py

 
         Args:
             query: Text to look up documents similar to.
-            k: Number of Documents to return. Defaults to 4.
 
         Returns:
             List of Documents most similar to the query.

api/core/rag/extractor/firecrawl/firecrawl_web_extractor.py

     """
     Crawl and scrape websites and return content in clean llm-ready markdown.
 
-
     Args:
         url: The URL to scrape.
-        api_key: The API key for Firecrawl.
-        base_url: The base URL for the Firecrawl API. Defaults to 'https://api.firecrawl.dev'.
+        job_id: The crawl job id.
+        tenant_id: The tenant id.
         mode: The mode of operation. Defaults to 'scrape'. Options are 'crawl', 'scrape' and 'crawl_return_urls'.
         only_main_content: Only return the main content of the page excluding headers, navs, footers, etc.
     """

api/core/rag/extractor/unstructured/unstructured_markdown_extractor.py

     Args:
         file_path: Path to the file to load.
 
-        remove_hyperlinks: Whether to remove hyperlinks from the text.
-
-        remove_images: Whether to remove images from the text.
-
-        encoding: File encoding to use. If `None`, the file will be loaded
-        with the default system encoding.
-
-        autodetect_encoding: Whether to try to autodetect the file encoding
-            if the specified encoding fails.
     """
 
     def __init__(self, file_path: str, api_url: Optional[str] = None, api_key: str = ""):

api/core/rag/retrieval/dataset_retrieval.py

         :param hit_callback: hit callback
         :param message_id: message id
         :param memory: memory
+        :param inputs: inputs
         :return:
         """
         dataset_ids = config.dataset_ids
         Calculate keywords scores
         :param query: search query
         :param documents: documents for reranking
+        :param top_k: top k
 
         :return:
         """
     ) -> tuple[ModelInstance, ModelConfigWithCredentialsEntity]:
         """
         Fetch model config
-        :param node_data: node data
-        :return:
         """
         if model is None:
             raise ValueError("single_retrieval_config is required")

api/core/rag/retrieval/router/multi_dataset_react_route.py

             tools: List of tools the agent will have access to, used to format the
                 prompt.
             prefix: String to put before the list of tools.
+            format_instructions: The format instruction prompt.
         Returns:
             A PromptTemplate with the template assembled from the pieces here.
         """

api/core/tools/__base/tool.py

 
     def fork_tool_runtime(self, runtime: ToolRuntime) -> "Tool":
         """
-        fork a new tool with meta data
-
-        :param meta: the meta data of a tool call processing, tenant_id is required
+        fork a new tool with metadata
         :return: the new tool
         """
         return self.__class__(
         create a blob message
 
         :param blob: the blob
+        :param meta: the meta info of blob object
         :return: the blob message
         """
         return ToolInvokeMessage(

api/core/tools/builtin_tool/provider.py

         """
         validate the credentials of the provider
 
-        :param tool_name: the name of the tool, defined in `get_tools`
+        :param user_id: use id
         :param credentials: the credentials of the tool
         """
         # validate credentials format
         """
         validate the credentials of the provider
 
-        :param tool_name: the name of the tool, defined in `get_tools`
+        :param user_id: use id
         :param credentials: the credentials of the tool
         """
         pass

api/core/tools/builtin_tool/tool.py

 
     def fork_tool_runtime(self, runtime: ToolRuntime) -> "BuiltinTool":
         """
-        fork a new tool with meta data
-
-        :param meta: the meta data of a tool call processing, tenant_id is required
+        fork a new tool with metadata
         :return: the new tool
         """
         return self.__class__(
         """
         invoke model
 
-        :param model_config: the model config
+        :param user_id: the user id
         :param prompt_messages: the prompt messages
         :param stop: the stop words
         :return: the model result
         """
         get max tokens
 
-        :param model_config: the model config
         :return: the max tokens
         """
         if self.runtime is None:

api/core/tools/custom_tool/provider.py

         """
         fetch tools from database
 
-        :param user_id: the user id
         :param tenant_id: the tenant id
         :return: the tools
         """

api/core/tools/custom_tool/tool.py

 
     def fork_tool_runtime(self, runtime: ToolRuntime):
         """
-        fork a new tool with meta data
-
-        :param meta: the meta data of a tool call processing, tenant_id is required
+        fork a new tool with metadata
         :return: the new tool
         """
         if self.api_bundle is None:

api/core/tools/entities/tool_entities.py

 
         :param name: the name of the parameter
         :param llm_description: the description presented to the LLM
-        :param type: the type of the parameter
+        :param typ: the type of the parameter
         :param required: if the parameter is required
         :param options: the options of the parameter
         """

api/core/tools/tool_engine.py

         """
         Create message file
 
-        :param messages: messages
         :return: message file ids
         """
         result = []

api/core/tools/tool_manager.py

         get the tool runtime
 
         :param provider_type: the type of the provider
-        :param provider_name: the name of the provider
+        :param provider_id: the id of the provider
         :param tool_name: the name of the tool
+        :param tenant_id: the tenant id
+        :param invoke_from: invoke from
+        :param tool_invoke_from: the tool invoke from
 
         :return: the tool
         """
         get the absolute path of the icon of the hardcoded provider
 
         :param provider: the name of the provider
-        :param tenant_id: the id of the tenant
-
         :return: the absolute path of the icon, the mime type of the icon
         """
         # get provider
         """
         get the api provider
 
-        :param provider_name: the name of the provider
+        :param tenant_id: the id of the tenant
+        :param provider_id: the id of the provider
 
         :return: the provider controller, the credentials
         """

api/core/tools/utils/model_invocation_utils.py

 
         :param user_id: user id
         :param tenant_id: tenant id, the tenant id of the creator of the tool
-        :param tool_provider: tool provider
-        :param tool_id: tool id
+        :param tool_type: tool type
         :param tool_name: tool name
-        :param provider: model provider
-        :param model: model name
-        :param model_parameters: model parameters
         :param prompt_messages: prompt messages
         :return: AssistantPromptMessage
         """

api/core/tools/utils/parser.py

         parse openapi yaml to tool bundle
 
         :param yaml: the yaml string
+        :param extra_info: the extra info
+        :param warning: the warning message
         :return: the tool bundle
         """
         warning = warning if warning is not None else {}
         parse openapi plugin yaml to tool bundle
 
         :param json: the json string
+        :param extra_info: the extra info
+        :param warning: the warning message
         :return: the tool bundle
         """
         warning = warning if warning is not None else {}
         auto parse to tool bundle
 
         :param content: the content
+        :param extra_info: the extra info
+        :param warning: the warning message
         :return: tools bundle, schema_type
         """
         warning = warning if warning is not None else {}

api/core/tools/workflow_as_tool/provider.py

         """
         fetch tools from database
 
-        :param user_id: the user id
         :param tenant_id: the tenant id
         :return: the tools
         """

api/core/tools/workflow_as_tool/tool.py

 
     def fork_tool_runtime(self, runtime: ToolRuntime) -> "WorkflowTool":
         """
-        fork a new tool with meta data
+        fork a new tool with metadata
 
-        :param meta: the meta data of a tool call processing, tenant_id is required
         :return: the new tool
         """
         return self.__class__(
         """
         extract files from the result
 
-        :param result: the result
         :return: the result, files
         """
         files: list[File] = []

api/core/workflow/utils/variable_template_parser.py

 
         Args:
             inputs: A dictionary containing the values for the template variables.
-            remove_template_variables: A boolean indicating whether to remove the template variables from the output.
 
         Returns:
             The formatted string with template variables replaced by their values.

api/core/workflow/workflow_entry.py

         NOTE: only parameter_extractor/question_classifier are supported
 
         :param node_data: node data
+        :param node_id: node id
+        :param tenant_id: tenant id
         :param user_id: user id
         :param user_inputs: user inputs
         :return:

api/services/app_dsl_service.py

         """
         Export app
         :param app_model: App instance
+        :param include_secret: Whether include secret variable
         :return:
         """
         app_mode = AppMode.value_of(app_model.mode)

api/services/tools/builtin_tools_manage_service.py

         """
         list builtin tool provider tools
 
-        :param user_id: the id of the user
         :param tenant_id: the id of the tenant
         :param provider: the name of the provider
 

api/services/tools/tools_transform_service.py

         """
         repack provider
 
+        :param tenant_id: the tenant id
         :param provider: the provider dict
         """
         if isinstance(provider, dict) and "icon" in provider:

api/services/tools/workflow_tools_manage_service.py

         Delete a workflow tool.
         :param user_id: the user id
         :param tenant_id: the tenant id
-        :param workflow_app_id: the workflow app id
+        :param workflow_tool_id: the workflow tool id
         """
         db.session.query(WorkflowToolProvider).filter(
             WorkflowToolProvider.tenant_id == tenant_id, WorkflowToolProvider.id == workflow_tool_id
         Get a workflow tool.
         :param user_id: the user id
         :param tenant_id: the tenant id
-        :param workflow_app_id: the workflow app id
+        :param workflow_tool_id: the workflow tool id
         :return: the tool
         """
         db_tool: WorkflowToolProvider | None = (
         List workflow tool provider tools.
         :param user_id: the user id
         :param tenant_id: the tenant id
-        :param workflow_app_id: the workflow app id
+        :param workflow_tool_id: the workflow tool id
         :return: the list of tools
         """
         db_tool: WorkflowToolProvider | None = (

api/tasks/mail_account_deletion_task.py

 
 @shared_task(queue="mail")
 def send_deletion_success_task(to):
-    """Send email to user regarding account deletion.
-
-    Args:
-        log (AccountDeletionLog): Account deletion log object
-    """
+    """Send email to user regarding account deletion."""
     if not mail.is_inited():
         return
 

api/tasks/ops_trace_task.py

 def process_trace_tasks(file_info):
     """
     Async process trace tasks
-    :param tasks_data: List of dictionaries containing task data
-
     Usage: process_trace_tasks.delay(tasks_data)
     """
     from core.ops.ops_trace_manager import OpsTraceManager