chore(api/core): apply ruff reformatting (#7624)

api/core/external_data_tool/api/api.py

@@ -30,10 +30,11 @@ class ApiExternalDataTool(ExternalDataTool):
             raise ValueError("api_based_extension_id is required")
 
         # get api_based_extension
-        api_based_extension = db.session.query(APIBasedExtension).filter(
-            APIBasedExtension.tenant_id == tenant_id,
-            APIBasedExtension.id == api_based_extension_id
-        ).first()
+        api_based_extension = (
+            db.session.query(APIBasedExtension)
+            .filter(APIBasedExtension.tenant_id == tenant_id, APIBasedExtension.id == api_based_extension_id)
+            .first()
+        )
 
         if not api_based_extension:
             raise ValueError("api_based_extension_id is invalid")
@@ -50,47 +51,42 @@ class ApiExternalDataTool(ExternalDataTool):
         api_based_extension_id = self.config.get("api_based_extension_id")
 
         # get api_based_extension
-        api_based_extension = db.session.query(APIBasedExtension).filter(
-            APIBasedExtension.tenant_id == self.tenant_id,
-            APIBasedExtension.id == api_based_extension_id
-        ).first()
+        api_based_extension = (
+            db.session.query(APIBasedExtension)
+            .filter(APIBasedExtension.tenant_id == self.tenant_id, APIBasedExtension.id == api_based_extension_id)
+            .first()
+        )
 
         if not api_based_extension:
-            raise ValueError("[External data tool] API query failed, variable: {}, "
-                             "error: api_based_extension_id is invalid"
-                             .format(self.variable))
+            raise ValueError(
+                "[External data tool] API query failed, variable: {}, "
+                "error: api_based_extension_id is invalid".format(self.variable)
+            )
 
         # decrypt api_key
-        api_key = encrypter.decrypt_token(
-            tenant_id=self.tenant_id,
-            token=api_based_extension.api_key
-        )
+        api_key = encrypter.decrypt_token(tenant_id=self.tenant_id, token=api_based_extension.api_key)
 
         try:
             # request api
-            requestor = APIBasedExtensionRequestor(
-                api_endpoint=api_based_extension.api_endpoint,
-                api_key=api_key
-            )
+            requestor = APIBasedExtensionRequestor(api_endpoint=api_based_extension.api_endpoint, api_key=api_key)
         except Exception as e:
-            raise ValueError("[External data tool] API query failed, variable: {}, error: {}".format(
-                self.variable,
-                e
-            ))
+            raise ValueError("[External data tool] API query failed, variable: {}, error: {}".format(self.variable, e))
 
-        response_json = requestor.request(point=APIBasedExtensionPoint.APP_EXTERNAL_DATA_TOOL_QUERY, params={
-            'app_id': self.app_id,
-            'tool_variable': self.variable,
-            'inputs': inputs,
-            'query': query
-        })
+        response_json = requestor.request(
+            point=APIBasedExtensionPoint.APP_EXTERNAL_DATA_TOOL_QUERY,
+            params={"app_id": self.app_id, "tool_variable": self.variable, "inputs": inputs, "query": query},
+        )
 
-        if 'result' not in response_json:
-            raise ValueError("[External data tool] API query failed, variable: {}, error: result not found in response"
-                             .format(self.variable))
+        if "result" not in response_json:
+            raise ValueError(
+                "[External data tool] API query failed, variable: {}, error: result not found in response".format(
+                    self.variable
+                )
+            )
 
-        if not isinstance(response_json['result'], str):
-            raise ValueError("[External data tool] API query failed, variable: {}, error: result is not string"
-                             .format(self.variable))
+        if not isinstance(response_json["result"], str):
+            raise ValueError(
+                "[External data tool] API query failed, variable: {}, error: result is not string".format(self.variable)
+            )
 
-        return response_json['result']
+        return response_json["result"]

api/core/external_data_tool/external_data_fetch.py

@@ -12,11 +12,14 @@ logger = logging.getLogger(__name__)
 
 
 class ExternalDataFetch:
-    def fetch(self, tenant_id: str,
-              app_id: str,
-              external_data_tools: list[ExternalDataVariableEntity],
-              inputs: dict,
-              query: str) -> dict:
+    def fetch(
+        self,
+        tenant_id: str,
+        app_id: str,
+        external_data_tools: list[ExternalDataVariableEntity],
+        inputs: dict,
+        query: str,
+    ) -> dict:
         """
         Fill in variable inputs from external data tools if exists.
 
@@ -38,7 +41,7 @@ class ExternalDataFetch:
                     app_id,
                     tool,
                     inputs,
-                    query
+                    query,
                 )
 
                 futures[future] = tool
@@ -50,12 +53,15 @@ class ExternalDataFetch:
         inputs.update(results)
         return inputs
 
-    def _query_external_data_tool(self, flask_app: Flask,
-                                  tenant_id: str,
-                                  app_id: str,
-                                  external_data_tool: ExternalDataVariableEntity,
-                                  inputs: dict,
-                                  query: str) -> tuple[Optional[str], Optional[str]]:
+    def _query_external_data_tool(
+        self,
+        flask_app: Flask,
+        tenant_id: str,
+        app_id: str,
+        external_data_tool: ExternalDataVariableEntity,
+        inputs: dict,
+        query: str,
+    ) -> tuple[Optional[str], Optional[str]]:
         """
         Query external data tool.
         :param flask_app: flask app
@@ -72,17 +78,10 @@ class ExternalDataFetch:
             tool_config = external_data_tool.config
 
             external_data_tool_factory = ExternalDataToolFactory(
-                name=tool_type,
-                tenant_id=tenant_id,
-                app_id=app_id,
-                variable=tool_variable,
-                config=tool_config
+                name=tool_type, tenant_id=tenant_id, app_id=app_id, variable=tool_variable, config=tool_config
             )
 
             # query external data tool
-            result = external_data_tool_factory.query(
-                inputs=inputs,
-                query=query
-            )
+            result = external_data_tool_factory.query(inputs=inputs, query=query)
 
             return tool_variable, result

api/core/external_data_tool/factory.py

@@ -5,14 +5,10 @@ from extensions.ext_code_based_extension import code_based_extension
 
 
 class ExternalDataToolFactory:
-
     def __init__(self, name: str, tenant_id: str, app_id: str, variable: str, config: dict) -> None:
         extension_class = code_based_extension.extension_class(ExtensionModule.EXTERNAL_DATA_TOOL, name)
         self.__extension_instance = extension_class(
-            tenant_id=tenant_id,
-            app_id=app_id,
-            variable=variable,
-            config=config
+            tenant_id=tenant_id, app_id=app_id, variable=variable, config=config
         )
 
     @classmethod