).filter( -> ).where(

api/commands.py

@@ -50,7 +50,7 @@ def reset_password(email, new_password, password_confirm):
         click.echo(click.style("Passwords do not match.", fg="red"))
         return
 
-    account = db.session.query(Account).filter(Account.email == email).one_or_none()
+    account = db.session.query(Account).where(Account.email == email).one_or_none()
 
     if not account:
         click.echo(click.style("Account not found for email: {}".format(email), fg="red"))
@@ -89,7 +89,7 @@ def reset_email(email, new_email, email_confirm):
         click.echo(click.style("New emails do not match.", fg="red"))
         return
 
-    account = db.session.query(Account).filter(Account.email == email).one_or_none()
+    account = db.session.query(Account).where(Account.email == email).one_or_none()
 
     if not account:
         click.echo(click.style("Account not found for email: {}".format(email), fg="red"))
@@ -136,8 +136,8 @@ def reset_encrypt_key_pair():
 
         tenant.encrypt_public_key = generate_key_pair(tenant.id)
 
-        db.session.query(Provider).filter(Provider.provider_type == "custom", Provider.tenant_id == tenant.id).delete()
-        db.session.query(ProviderModel).filter(ProviderModel.tenant_id == tenant.id).delete()
+        db.session.query(Provider).where(Provider.provider_type == "custom", Provider.tenant_id == tenant.id).delete()
+        db.session.query(ProviderModel).where(ProviderModel.tenant_id == tenant.id).delete()
         db.session.commit()
 
         click.echo(
@@ -192,7 +192,7 @@ def migrate_annotation_vector_database():
             try:
                 click.echo("Creating app annotation index: {}".format(app.id))
                 app_annotation_setting = (
-                    db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app.id).first()
+                    db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app.id).first()
                 )
 
                 if not app_annotation_setting:
@@ -208,7 +208,7 @@ def migrate_annotation_vector_database():
                 if not dataset_collection_binding:
                     click.echo("App annotation collection binding not found: {}".format(app.id))
                     continue
-                annotations = db.session.query(MessageAnnotation).filter(MessageAnnotation.app_id == app.id).all()
+                annotations = db.session.query(MessageAnnotation).where(MessageAnnotation.app_id == app.id).all()
                 dataset = Dataset(
                     id=app.id,
                     tenant_id=app.tenant_id,
@@ -305,7 +305,7 @@ def migrate_knowledge_vector_database():
     while True:
         try:
             stmt = (
-                select(Dataset).filter(Dataset.indexing_technique == "high_quality").order_by(Dataset.created_at.desc())
+                select(Dataset).where(Dataset.indexing_technique == "high_quality").order_by(Dataset.created_at.desc())
             )
 
             datasets = db.paginate(select=stmt, page=page, per_page=50, max_per_page=50, error_out=False)
@@ -468,7 +468,7 @@ def convert_to_agent_apps():
                 app_id = str(i.id)
                 if app_id not in proceeded_app_ids:
                     proceeded_app_ids.append(app_id)
-                    app = db.session.query(App).filter(App.id == app_id).first()
+                    app = db.session.query(App).where(App.id == app_id).first()
                     if app is not None:
                         apps.append(app)
 
@@ -483,7 +483,7 @@ def convert_to_agent_apps():
                 db.session.commit()
 
                 # update conversation mode to agent
-                db.session.query(Conversation).filter(Conversation.app_id == app.id).update(
+                db.session.query(Conversation).where(Conversation.app_id == app.id).update(
                     {Conversation.mode: AppMode.AGENT_CHAT.value}
                 )
 
@@ -717,7 +717,7 @@ where sites.id is null limit 1000"""
                     continue
 
                 try:
-                    app = db.session.query(App).filter(App.id == app_id).first()
+                    app = db.session.query(App).where(App.id == app_id).first()
                     if not app:
                         print(f"App {app_id} not found")
                         continue

api/controllers/console/admin.py

@@ -56,7 +56,7 @@ class InsertExploreAppListApi(Resource):
         parser.add_argument("position", type=int, required=True, nullable=False, location="json")
         args = parser.parse_args()
 
-        app = db.session.execute(select(App).filter(App.id == args["app_id"])).scalar_one_or_none()
+        app = db.session.execute(select(App).where(App.id == args["app_id"])).scalar_one_or_none()
         if not app:
             raise NotFound(f"App '{args['app_id']}' is not found")
 
@@ -74,7 +74,7 @@ class InsertExploreAppListApi(Resource):
 
         with Session(db.engine) as session:
             recommended_app = session.execute(
-                select(RecommendedApp).filter(RecommendedApp.app_id == args["app_id"])
+                select(RecommendedApp).where(RecommendedApp.app_id == args["app_id"])
             ).scalar_one_or_none()
 
             if not recommended_app:
@@ -117,21 +117,21 @@ class InsertExploreAppApi(Resource):
     def delete(self, app_id):
         with Session(db.engine) as session:
             recommended_app = session.execute(
-                select(RecommendedApp).filter(RecommendedApp.app_id == str(app_id))
+                select(RecommendedApp).where(RecommendedApp.app_id == str(app_id))
             ).scalar_one_or_none()
 
         if not recommended_app:
             return {"result": "success"}, 204
 
         with Session(db.engine) as session:
-            app = session.execute(select(App).filter(App.id == recommended_app.app_id)).scalar_one_or_none()
+            app = session.execute(select(App).where(App.id == recommended_app.app_id)).scalar_one_or_none()
 
         if app:
             app.is_public = False
 
         with Session(db.engine) as session:
             installed_apps = session.execute(
-                select(InstalledApp).filter(
+                select(InstalledApp).where(
                     InstalledApp.app_id == recommended_app.app_id,
                     InstalledApp.tenant_id != InstalledApp.app_owner_tenant_id,
                 )

api/controllers/console/apikey.py

@@ -128,7 +128,7 @@ class BaseApiKeyResource(Resource):
         if key is None:
             flask_restful.abort(404, message="API key not found")
 
-        db.session.query(ApiToken).filter(ApiToken.id == api_key_id).delete()
+        db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
         db.session.commit()
 
         return {"result": "success"}, 204

api/controllers/console/app/conversation.py

@@ -49,7 +49,7 @@ class CompletionConversationApi(Resource):
         query = db.select(Conversation).where(Conversation.app_id == app_model.id, Conversation.mode == "completion")
 
         if args["keyword"]:
-            query = query.join(Message, Message.conversation_id == Conversation.id).filter(
+            query = query.join(Message, Message.conversation_id == Conversation.id).where(
                 or_(
                     Message.query.ilike("%{}%".format(args["keyword"])),
                     Message.answer.ilike("%{}%".format(args["keyword"])),

api/controllers/console/app/mcp_server.py

@@ -26,7 +26,7 @@ class AppMCPServerController(Resource):
     @get_app_model
     @marshal_with(app_server_fields)
     def get(self, app_model):
-        server = db.session.query(AppMCPServer).filter(AppMCPServer.app_id == app_model.id).first()
+        server = db.session.query(AppMCPServer).where(AppMCPServer.app_id == app_model.id).first()
         return server
 
     @setup_required
@@ -73,7 +73,7 @@ class AppMCPServerController(Resource):
         parser.add_argument("parameters", type=dict, required=True, location="json")
         parser.add_argument("status", type=str, required=False, location="json")
         args = parser.parse_args()
-        server = db.session.query(AppMCPServer).filter(AppMCPServer.id == args["id"]).first()
+        server = db.session.query(AppMCPServer).where(AppMCPServer.id == args["id"]).first()
         if not server:
             raise NotFound()
 

api/controllers/console/app/message.py

@@ -167,7 +167,7 @@ class MessageAnnotationCountApi(Resource):
     @account_initialization_required
     @get_app_model
     def get(self, app_model):
-        count = db.session.query(MessageAnnotation).filter(MessageAnnotation.app_id == app_model.id).count()
+        count = db.session.query(MessageAnnotation).where(MessageAnnotation.app_id == app_model.id).count()
 
         return {"count": count}
 
@@ -214,7 +214,7 @@ class MessageApi(Resource):
     def get(self, app_model, message_id):
         message_id = str(message_id)
 
-        message = db.session.query(Message).filter(Message.id == message_id, Message.app_id == app_model.id).first()
+        message = db.session.query(Message).where(Message.id == message_id, Message.app_id == app_model.id).first()
 
         if not message:
             raise NotFound("Message Not Exists.")

api/controllers/console/app/model_config.py

@@ -42,7 +42,7 @@ class ModelConfigResource(Resource):
         if app_model.mode == AppMode.AGENT_CHAT.value or app_model.is_agent:
             # get original app model config
             original_app_model_config = (
-                db.session.query(AppModelConfig).filter(AppModelConfig.id == app_model.app_model_config_id).first()
+                db.session.query(AppModelConfig).where(AppModelConfig.id == app_model.app_model_config_id).first()
             )
             if original_app_model_config is None:
                 raise ValueError("Original app model config not found")

api/controllers/console/app/site.py

@@ -49,7 +49,7 @@ class AppSite(Resource):
         if not current_user.is_editor:
             raise Forbidden()
 
-        site = db.session.query(Site).filter(Site.app_id == app_model.id).first()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
         if not site:
             raise NotFound
 
@@ -93,7 +93,7 @@ class AppSiteAccessTokenReset(Resource):
         if not current_user.is_admin_or_owner:
             raise Forbidden()
 
-        site = db.session.query(Site).filter(Site.app_id == app_model.id).first()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
 
         if not site:
             raise NotFound

api/controllers/console/datasets/data_source.py

@@ -171,7 +171,7 @@ class DataSourceNotionApi(Resource):
         page_id = str(page_id)
         with Session(db.engine) as session:
             data_source_binding = session.execute(
-                select(DataSourceOauthBinding).filter(
+                select(DataSourceOauthBinding).where(
                     db.and_(
                         DataSourceOauthBinding.tenant_id == current_user.current_tenant_id,
                         DataSourceOauthBinding.provider == "notion",

api/controllers/console/datasets/datasets.py

@@ -631,7 +631,7 @@ class DatasetApiDeleteApi(Resource):
         if key is None:
             flask_restful.abort(404, message="API key not found")
 
-        db.session.query(ApiToken).filter(ApiToken.id == api_key_id).delete()
+        db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
         db.session.commit()
 
         return {"result": "success"}, 204

api/controllers/console/explore/installed_app.py

@@ -38,7 +38,7 @@ class InstalledAppsListApi(Resource):
                 .all()
             )
         else:
-            installed_apps = db.session.query(InstalledApp).filter(InstalledApp.tenant_id == current_tenant_id).all()
+            installed_apps = db.session.query(InstalledApp).where(InstalledApp.tenant_id == current_tenant_id).all()
 
         current_user.role = TenantService.get_user_role(current_user, current_user.current_tenant)
         installed_app_list: list[dict[str, Any]] = [
@@ -94,12 +94,12 @@ class InstalledAppsListApi(Resource):
         parser.add_argument("app_id", type=str, required=True, help="Invalid app_id")
         args = parser.parse_args()
 
-        recommended_app = db.session.query(RecommendedApp).filter(RecommendedApp.app_id == args["app_id"]).first()
+        recommended_app = db.session.query(RecommendedApp).where(RecommendedApp.app_id == args["app_id"]).first()
         if recommended_app is None:
             raise NotFound("App not found")
 
         current_tenant_id = current_user.current_tenant_id
-        app = db.session.query(App).filter(App.id == args["app_id"]).first()
+        app = db.session.query(App).where(App.id == args["app_id"]).first()
 
         if app is None:
             raise NotFound("App not found")

api/controllers/console/workspace/account.py

@@ -228,7 +228,7 @@ class AccountIntegrateApi(Resource):
     def get(self):
         account = current_user
 
-        account_integrates = db.session.query(AccountIntegrate).filter(AccountIntegrate.account_id == account.id).all()
+        account_integrates = db.session.query(AccountIntegrate).where(AccountIntegrate.account_id == account.id).all()
 
         base_url = request.url_root.rstrip("/")
         oauth_base_path = "/console/api/oauth/login"

api/controllers/console/workspace/members.py

@@ -108,7 +108,7 @@ class MemberCancelInviteApi(Resource):
     @login_required
     @account_initialization_required
     def delete(self, member_id):
-        member = db.session.query(Account).filter(Account.id == str(member_id)).first()
+        member = db.session.query(Account).where(Account.id == str(member_id)).first()
         if member is None:
             abort(404)
         else:

api/controllers/inner_api/plugin/wraps.py

@@ -22,7 +22,7 @@ def get_user(tenant_id: str, user_id: str | None) -> Account | EndUser:
                 user_id = "DEFAULT-USER"
 
             if user_id == "DEFAULT-USER":
-                user_model = session.query(EndUser).filter(EndUser.session_id == "DEFAULT-USER").first()
+                user_model = session.query(EndUser).where(EndUser.session_id == "DEFAULT-USER").first()
                 if not user_model:
                     user_model = EndUser(
                         tenant_id=tenant_id,
@@ -36,7 +36,7 @@ def get_user(tenant_id: str, user_id: str | None) -> Account | EndUser:
             else:
                 user_model = AccountService.load_user(user_id)
                 if not user_model:
-                    user_model = session.query(EndUser).filter(EndUser.id == user_id).first()
+                    user_model = session.query(EndUser).where(EndUser.id == user_id).first()
                 if not user_model:
                     raise ValueError("user not found")
     except Exception:

api/controllers/inner_api/wraps.py

@@ -55,7 +55,7 @@ def enterprise_inner_api_user_auth(view):
         if signature_base64 != token:
             return view(*args, **kwargs)
 
-        kwargs["user"] = db.session.query(EndUser).filter(EndUser.id == user_id).first()
+        kwargs["user"] = db.session.query(EndUser).where(EndUser.id == user_id).first()
 
         return view(*args, **kwargs)
 

api/controllers/mcp/mcp.py

@@ -30,7 +30,7 @@ class MCPAppApi(Resource):
 
         request_id = args.get("id")
 
-        server = db.session.query(AppMCPServer).filter(AppMCPServer.server_code == server_code).first()
+        server = db.session.query(AppMCPServer).where(AppMCPServer.server_code == server_code).first()
         if not server:
             return helper.compact_generate_response(
                 create_mcp_error_response(request_id, types.INVALID_REQUEST, "Server Not Found")
@@ -41,7 +41,7 @@ class MCPAppApi(Resource):
                 create_mcp_error_response(request_id, types.INVALID_REQUEST, "Server is not active")
             )
 
-        app = db.session.query(App).filter(App.id == server.app_id).first()
+        app = db.session.query(App).where(App.id == server.app_id).first()
         if not app:
             return helper.compact_generate_response(
                 create_mcp_error_response(request_id, types.INVALID_REQUEST, "App Not Found")

api/controllers/service_api/app/site.py

@@ -16,7 +16,7 @@ class AppSiteApi(Resource):
     @marshal_with(fields.site_fields)
     def get(self, app_model: App):
         """Retrieve app site info."""
-        site = db.session.query(Site).filter(Site.app_id == app_model.id).first()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
 
         if not site:
             raise Forbidden()

api/controllers/service_api/dataset/document.py

@@ -63,7 +63,7 @@ class DocumentAddByTextApi(DatasetApiResource):
 
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
         if not dataset:
             raise ValueError("Dataset does not exist.")
@@ -136,7 +136,7 @@ class DocumentUpdateByTextApi(DatasetApiResource):
         args = parser.parse_args()
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
         if not dataset:
             raise ValueError("Dataset does not exist.")
@@ -206,7 +206,7 @@ class DocumentAddByFileApi(DatasetApiResource):
         # get dataset info
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
         if not dataset:
             raise ValueError("Dataset does not exist.")
@@ -299,7 +299,7 @@ class DocumentUpdateByFileApi(DatasetApiResource):
         # get dataset info
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
         if not dataset:
             raise ValueError("Dataset does not exist.")
@@ -367,7 +367,7 @@ class DocumentDeleteApi(DatasetApiResource):
         tenant_id = str(tenant_id)
 
         # get dataset info
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
         if not dataset:
             raise ValueError("Dataset does not exist.")
@@ -398,7 +398,7 @@ class DocumentListApi(DatasetApiResource):
         page = request.args.get("page", default=1, type=int)
         limit = request.args.get("limit", default=20, type=int)
         search = request.args.get("keyword", default=None, type=str)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 
@@ -430,7 +430,7 @@ class DocumentIndexingStatusApi(DatasetApiResource):
         batch = str(batch)
         tenant_id = str(tenant_id)
         # get dataset
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # get documents

api/controllers/service_api/dataset/segment.py

@@ -42,7 +42,7 @@ class SegmentApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check document
@@ -89,7 +89,7 @@ class SegmentApi(DatasetApiResource):
         tenant_id = str(tenant_id)
         page = request.args.get("page", default=1, type=int)
         limit = request.args.get("limit", default=20, type=int)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check document
@@ -146,7 +146,7 @@ class DatasetSegmentApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check user's model setting
@@ -170,7 +170,7 @@ class DatasetSegmentApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check user's model setting
@@ -216,7 +216,7 @@ class DatasetSegmentApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check user's model setting
@@ -246,7 +246,7 @@ class ChildChunkApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 
@@ -296,7 +296,7 @@ class ChildChunkApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 
@@ -343,7 +343,7 @@ class DatasetChildChunkApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 
@@ -382,7 +382,7 @@ class DatasetChildChunkApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 

api/controllers/service_api/dataset/upload_file.py

@@ -17,7 +17,7 @@ class UploadFileApi(DatasetApiResource):
         # check dataset
         dataset_id = str(dataset_id)
         tenant_id = str(tenant_id)
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
         # check document
@@ -31,7 +31,7 @@ class UploadFileApi(DatasetApiResource):
         data_source_info = document.data_source_info_dict
         if data_source_info and "upload_file_id" in data_source_info:
             file_id = data_source_info["upload_file_id"]
-            upload_file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+            upload_file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
             if not upload_file:
                 raise NotFound("UploadFile not found.")
         else:

api/controllers/service_api/wraps.py

@@ -44,7 +44,7 @@ def validate_app_token(view: Optional[Callable] = None, *, fetch_user_arg: Optio
         def decorated_view(*args, **kwargs):
             api_token = validate_and_get_api_token("app")
 
-            app_model = db.session.query(App).filter(App.id == api_token.app_id).first()
+            app_model = db.session.query(App).where(App.id == api_token.app_id).first()
             if not app_model:
                 raise Forbidden("The app no longer exists.")
 
@@ -54,7 +54,7 @@ def validate_app_token(view: Optional[Callable] = None, *, fetch_user_arg: Optio
             if not app_model.enable_api:
                 raise Forbidden("The app's API service has been disabled.")
 
-            tenant = db.session.query(Tenant).filter(Tenant.id == app_model.tenant_id).first()
+            tenant = db.session.query(Tenant).where(Tenant.id == app_model.tenant_id).first()
             if tenant is None:
                 raise ValueError("Tenant does not exist.")
             if tenant.status == TenantStatus.ARCHIVE:
@@ -70,7 +70,7 @@ def validate_app_token(view: Optional[Callable] = None, *, fetch_user_arg: Optio
             )  # TODO: only owner information is required, so only one is returned.
             if tenant_account_join:
                 tenant, ta = tenant_account_join
-                account = db.session.query(Account).filter(Account.id == ta.account_id).first()
+                account = db.session.query(Account).where(Account.id == ta.account_id).first()
                 # Login admin
                 if account:
                     account.current_tenant = tenant
@@ -221,7 +221,7 @@ def validate_dataset_token(view=None):
             )  # TODO: only owner information is required, so only one is returned.
             if tenant_account_join:
                 tenant, ta = tenant_account_join
-                account = db.session.query(Account).filter(Account.id == ta.account_id).first()
+                account = db.session.query(Account).where(Account.id == ta.account_id).first()
                 # Login admin
                 if account:
                     account.current_tenant = tenant
@@ -320,7 +320,7 @@ class DatasetApiResource(Resource):
     method_decorators = [validate_dataset_token]
 
     def get_dataset(self, dataset_id: str, tenant_id: str) -> Dataset:
-        dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id, Dataset.tenant_id == tenant_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.id == dataset_id, Dataset.tenant_id == tenant_id).first()
 
         if not dataset:
             raise NotFound("Dataset not found.")

api/controllers/web/passport.py

@@ -47,13 +47,13 @@ class PassportResource(Resource):
         if not site:
             raise NotFound()
         # get app from db and check if it is normal and enable_site
-        app_model = db.session.scalar(select(App).filter(App.id == site.app_id))
+        app_model = db.session.scalar(select(App).where(App.id == site.app_id))
         if not app_model or app_model.status != "normal" or not app_model.enable_site:
             raise NotFound()
 
         if user_id:
             end_user = db.session.scalar(
-                select(EndUser).filter(EndUser.app_id == app_model.id, EndUser.session_id == user_id)
+                select(EndUser).where(EndUser.app_id == app_model.id, EndUser.session_id == user_id)
             )
 
             if end_user:
@@ -122,11 +122,11 @@ def exchange_token_for_existing_web_user(app_code: str, enterprise_user_decoded:
     if not user_auth_type:
         raise Unauthorized("Missing auth_type in the token.")
 
-    site = db.session.scalar(select(Site).filter(Site.code == app_code, Site.status == "normal"))
+    site = db.session.scalar(select(Site).where(Site.code == app_code, Site.status == "normal"))
     if not site:
         raise NotFound()
 
-    app_model = db.session.scalar(select(App).filter(App.id == site.app_id))
+    app_model = db.session.scalar(select(App).where(App.id == site.app_id))
     if not app_model or app_model.status != "normal" or not app_model.enable_site:
         raise NotFound()
 
@@ -141,10 +141,10 @@ def exchange_token_for_existing_web_user(app_code: str, enterprise_user_decoded:
 
     end_user = None
     if end_user_id:
-        end_user = db.session.scalar(select(EndUser).filter(EndUser.id == end_user_id))
+        end_user = db.session.scalar(select(EndUser).where(EndUser.id == end_user_id))
     if session_id:
         end_user = db.session.scalar(
-            select(EndUser).filter(
+            select(EndUser).where(
                 EndUser.session_id == session_id,
                 EndUser.tenant_id == app_model.tenant_id,
                 EndUser.app_id == app_model.id,
@@ -187,7 +187,7 @@ def _exchange_for_public_app_token(app_model, site, token_decoded):
     end_user = None
     if user_id:
         end_user = db.session.scalar(
-            select(EndUser).filter(EndUser.app_id == app_model.id, EndUser.session_id == user_id)
+            select(EndUser).where(EndUser.app_id == app_model.id, EndUser.session_id == user_id)
         )
 
     if not end_user:
@@ -224,7 +224,7 @@ def generate_session_id():
     while True:
         session_id = str(uuid.uuid4())
         existing_count = db.session.scalar(
-            select(func.count()).select_from(EndUser).filter(EndUser.session_id == session_id)
+            select(func.count()).select_from(EndUser).where(EndUser.session_id == session_id)
         )
         if existing_count == 0:
             return session_id

api/controllers/web/site.py

@@ -57,7 +57,7 @@ class AppSiteApi(WebApiResource):
     def get(self, app_model, end_user):
         """Retrieve app site info."""
         # get site
-        site = db.session.query(Site).filter(Site.app_id == app_model.id).first()
+        site = db.session.query(Site).where(Site.app_id == app_model.id).first()
 
         if not site:
             raise Forbidden()

api/controllers/web/wraps.py

@@ -49,8 +49,8 @@ def decode_jwt_token():
         decoded = PassportService().verify(tk)
         app_code = decoded.get("app_code")
         app_id = decoded.get("app_id")
-        app_model = db.session.scalar(select(App).filter(App.id == app_id))
-        site = db.session.scalar(select(Site).filter(Site.code == app_code))
+        app_model = db.session.scalar(select(App).where(App.id == app_id))
+        site = db.session.scalar(select(Site).where(Site.code == app_code))
         if not app_model:
             raise NotFound()
         if not app_code or not site:
@@ -58,7 +58,7 @@ def decode_jwt_token():
         if app_model.enable_site is False:
             raise BadRequest("Site is disabled.")
         end_user_id = decoded.get("end_user_id")
-        end_user = db.session.scalar(select(EndUser).filter(EndUser.id == end_user_id))
+        end_user = db.session.scalar(select(EndUser).where(EndUser.id == end_user_id))
         if not end_user:
             raise NotFound()
 

api/core/agent/base_agent_runner.py

@@ -336,7 +336,7 @@ class BaseAgentRunner(AppRunner):
         Save agent thought
         """
         updated_agent_thought = (
-            db.session.query(MessageAgentThought).filter(MessageAgentThought.id == agent_thought.id).first()
+            db.session.query(MessageAgentThought).where(MessageAgentThought.id == agent_thought.id).first()
         )
         if not updated_agent_thought:
             raise ValueError("agent thought not found")
@@ -496,7 +496,7 @@ class BaseAgentRunner(AppRunner):
         return result
 
     def organize_agent_user_prompt(self, message: Message) -> UserPromptMessage:
-        files = db.session.query(MessageFile).filter(MessageFile.message_id == message.id).all()
+        files = db.session.query(MessageFile).where(MessageFile.message_id == message.id).all()
         if not files:
             return UserPromptMessage(content=message.query)
         if message.app_model_config:

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

@@ -72,7 +72,7 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
         app_config = self.application_generate_entity.app_config
         app_config = cast(AdvancedChatAppConfig, app_config)
 
-        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        app_record = db.session.query(App).where(App.id == app_config.app_id).first()
         if not app_record:
             raise ValueError("App not found")
 

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

@@ -45,7 +45,7 @@ class AgentChatAppRunner(AppRunner):
         app_config = application_generate_entity.app_config
         app_config = cast(AgentChatAppConfig, app_config)
 
-        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        app_record = db.session.query(App).where(App.id == app_config.app_id).first()
         if not app_record:
             raise ValueError("App not found")
 
@@ -183,10 +183,10 @@ class AgentChatAppRunner(AppRunner):
         if {ModelFeature.MULTI_TOOL_CALL, ModelFeature.TOOL_CALL}.intersection(model_schema.features or []):
             agent_entity.strategy = AgentEntity.Strategy.FUNCTION_CALLING
 
-        conversation_result = db.session.query(Conversation).filter(Conversation.id == conversation.id).first()
+        conversation_result = db.session.query(Conversation).where(Conversation.id == conversation.id).first()
         if conversation_result is None:
             raise ValueError("Conversation not found")
-        message_result = db.session.query(Message).filter(Message.id == message.id).first()
+        message_result = db.session.query(Message).where(Message.id == message.id).first()
         if message_result is None:
             raise ValueError("Message not found")
         db.session.close()

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

@@ -43,7 +43,7 @@ class ChatAppRunner(AppRunner):
         app_config = application_generate_entity.app_config
         app_config = cast(ChatAppConfig, app_config)
 
-        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        app_record = db.session.query(App).where(App.id == app_config.app_id).first()
         if not app_record:
             raise ValueError("App not found")
 

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

@@ -36,7 +36,7 @@ class CompletionAppRunner(AppRunner):
         app_config = application_generate_entity.app_config
         app_config = cast(CompletionAppConfig, app_config)
 
-        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        app_record = db.session.query(App).where(App.id == app_config.app_id).first()
         if not app_record:
             raise ValueError("App not found")
 

api/core/app/apps/message_based_app_generator.py

@@ -259,7 +259,7 @@ class MessageBasedAppGenerator(BaseAppGenerator):
         :param conversation_id: conversation id
         :return: conversation
         """
-        conversation = db.session.query(Conversation).filter(Conversation.id == conversation_id).first()
+        conversation = db.session.query(Conversation).where(Conversation.id == conversation_id).first()
 
         if not conversation:
             raise ConversationNotExistsError("Conversation not exists")
@@ -272,7 +272,7 @@ class MessageBasedAppGenerator(BaseAppGenerator):
         :param message_id: message id
         :return: message
         """
-        message = db.session.query(Message).filter(Message.id == message_id).first()
+        message = db.session.query(Message).where(Message.id == message_id).first()
 
         if message is None:
             raise MessageNotExistsError("Message not exists")

api/core/app/features/annotation_reply/annotation_reply.py

@@ -26,7 +26,7 @@ class AnnotationReplyFeature:
         :return:
         """
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_record.id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_record.id).first()
         )
 
         if not annotation_setting:

api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py

@@ -471,7 +471,7 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
         :return:
         """
         agent_thought: Optional[MessageAgentThought] = (
-            db.session.query(MessageAgentThought).filter(MessageAgentThought.id == event.agent_thought_id).first()
+            db.session.query(MessageAgentThought).where(MessageAgentThought.id == event.agent_thought_id).first()
         )
 
         if agent_thought:

api/core/app/task_pipeline/message_cycle_manager.py

@@ -81,7 +81,7 @@ class MessageCycleManager:
     def _generate_conversation_name_worker(self, flask_app: Flask, conversation_id: str, query: str):
         with flask_app.app_context():
             # get conversation and message
-            conversation = db.session.query(Conversation).filter(Conversation.id == conversation_id).first()
+            conversation = db.session.query(Conversation).where(Conversation.id == conversation_id).first()
 
             if not conversation:
                 return
@@ -140,7 +140,7 @@ class MessageCycleManager:
         :param event: event
         :return:
         """
-        message_file = db.session.query(MessageFile).filter(MessageFile.id == event.message_file_id).first()
+        message_file = db.session.query(MessageFile).where(MessageFile.id == event.message_file_id).first()
 
         if message_file and message_file.url is not None:
             # get tool file id

api/core/callback_handler/index_tool_callback_handler.py

@@ -49,7 +49,7 @@ class DatasetIndexToolCallbackHandler:
         for document in documents:
             if document.metadata is not None:
                 document_id = document.metadata["document_id"]
-                dataset_document = db.session.query(DatasetDocument).filter(DatasetDocument.id == document_id).first()
+                dataset_document = db.session.query(DatasetDocument).where(DatasetDocument.id == document_id).first()
                 if not dataset_document:
                     _logger.warning(
                         "Expected DatasetDocument record to exist, but none was found, document_id=%s",
@@ -75,7 +75,7 @@ class DatasetIndexToolCallbackHandler:
                             )
                         )
                 else:
-                    query = db.session.query(DocumentSegment).filter(
+                    query = db.session.query(DocumentSegment).where(
                         DocumentSegment.index_node_id == document.metadata["doc_id"]
                     )
 

api/core/helper/encrypter.py

@@ -15,7 +15,7 @@ def encrypt_token(tenant_id: str, token: str):
     from models.account import Tenant
     from models.engine import db
 
-    if not (tenant := db.session.query(Tenant).filter(Tenant.id == tenant_id).first()):
+    if not (tenant := db.session.query(Tenant).where(Tenant.id == tenant_id).first()):
         raise ValueError(f"Tenant with id {tenant_id} not found")
     encrypted_token = rsa.encrypt(token, tenant.encrypt_public_key)
     return base64.b64encode(encrypted_token).decode()

api/core/indexing_runner.py

@@ -119,7 +119,7 @@ class IndexingRunner:
                 db.session.delete(document_segment)
                 if dataset_document.doc_form == IndexType.PARENT_CHILD_INDEX:
                     # delete child chunks
-                    db.session.query(ChildChunk).filter(ChildChunk.segment_id == document_segment.id).delete()
+                    db.session.query(ChildChunk).where(ChildChunk.segment_id == document_segment.id).delete()
             db.session.commit()
             # get the process rule
             processing_rule = (
@@ -316,7 +316,7 @@ class IndexingRunner:
                 # delete image files and related db records
                 image_upload_file_ids = get_image_upload_file_ids(document.page_content)
                 for upload_file_id in image_upload_file_ids:
-                    image_file = db.session.query(UploadFile).filter(UploadFile.id == upload_file_id).first()
+                    image_file = db.session.query(UploadFile).where(UploadFile.id == upload_file_id).first()
                     if image_file is None:
                         continue
                     try:
@@ -346,7 +346,7 @@ class IndexingRunner:
                 raise ValueError("no upload file found")
 
             file_detail = (
-                db.session.query(UploadFile).filter(UploadFile.id == data_source_info["upload_file_id"]).one_or_none()
+                db.session.query(UploadFile).where(UploadFile.id == data_source_info["upload_file_id"]).one_or_none()
             )
 
             if file_detail:
@@ -599,7 +599,7 @@ class IndexingRunner:
             keyword.create(documents)
             if dataset.indexing_technique != "high_quality":
                 document_ids = [document.metadata["doc_id"] for document in documents]
-                db.session.query(DocumentSegment).filter(
+                db.session.query(DocumentSegment).where(
                     DocumentSegment.document_id == document_id,
                     DocumentSegment.dataset_id == dataset_id,
                     DocumentSegment.index_node_id.in_(document_ids),
@@ -630,7 +630,7 @@ class IndexingRunner:
             index_processor.load(dataset, chunk_documents, with_keywords=False)
 
             document_ids = [document.metadata["doc_id"] for document in chunk_documents]
-            db.session.query(DocumentSegment).filter(
+            db.session.query(DocumentSegment).where(
                 DocumentSegment.document_id == dataset_document.id,
                 DocumentSegment.dataset_id == dataset.id,
                 DocumentSegment.index_node_id.in_(document_ids),

api/core/mcp/server/streamable_http.py

@@ -28,7 +28,7 @@ class MCPServerStreamableHTTPRequestHandler:
     ):
         self.app = app
         self.request = request
-        mcp_server = db.session.query(AppMCPServer).filter(AppMCPServer.app_id == self.app.id).first()
+        mcp_server = db.session.query(AppMCPServer).where(AppMCPServer.app_id == self.app.id).first()
         if not mcp_server:
             raise ValueError("MCP server not found")
         self.mcp_server: AppMCPServer = mcp_server

api/core/memory/token_buffer_memory.py

@@ -67,7 +67,7 @@ class TokenBufferMemory:
 
         prompt_messages: list[PromptMessage] = []
         for message in messages:
-            files = db.session.query(MessageFile).filter(MessageFile.message_id == message.id).all()
+            files = db.session.query(MessageFile).where(MessageFile.message_id == message.id).all()
             if files:
                 file_extra_config = None
                 if self.conversation.mode in {AppMode.AGENT_CHAT, AppMode.COMPLETION, AppMode.CHAT}:

api/core/ops/aliyun_trace/aliyun_trace.py

@@ -120,7 +120,7 @@ class AliyunDataTrace(BaseTraceInstance):
         user_id = message_data.from_account_id
         if message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 user_id = end_user_data.session_id
@@ -244,14 +244,14 @@ class AliyunDataTrace(BaseTraceInstance):
             if not app_id:
                 raise ValueError("No app_id found in trace_info metadata")
 
-            app = session.query(App).filter(App.id == app_id).first()
+            app = session.query(App).where(App.id == app_id).first()
             if not app:
                 raise ValueError(f"App with id {app_id} not found")
 
             if not app.created_by:
                 raise ValueError(f"App with id {app_id} has no creator (created_by is None)")
 
-            service_account = session.query(Account).filter(Account.id == app.created_by).first()
+            service_account = session.query(Account).where(Account.id == app.created_by).first()
             if not service_account:
                 raise ValueError(f"Creator account with id {app.created_by} not found for app {app_id}")
             current_tenant = (

api/core/ops/arize_phoenix_trace/arize_phoenix_trace.py

@@ -297,7 +297,7 @@ class ArizePhoenixDataTrace(BaseTraceInstance):
         # Add end user data if available
         if trace_info.message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == trace_info.message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == trace_info.message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 message_metadata["end_user_id"] = end_user_data.session_id

api/core/ops/base_trace_instance.py

@@ -44,14 +44,14 @@ class BaseTraceInstance(ABC):
         """
         with Session(db.engine, expire_on_commit=False) as session:
             # Get the app to find its creator
-            app = session.query(App).filter(App.id == app_id).first()
+            app = session.query(App).where(App.id == app_id).first()
             if not app:
                 raise ValueError(f"App with id {app_id} not found")
 
             if not app.created_by:
                 raise ValueError(f"App with id {app_id} has no creator (created_by is None)")
 
-            service_account = session.query(Account).filter(Account.id == app.created_by).first()
+            service_account = session.query(Account).where(Account.id == app.created_by).first()
             if not service_account:
                 raise ValueError(f"Creator account with id {app.created_by} not found for app {app_id}")
 

api/core/ops/langfuse_trace/langfuse_trace.py

@@ -244,7 +244,7 @@ class LangFuseDataTrace(BaseTraceInstance):
         user_id = message_data.from_account_id
         if message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 user_id = end_user_data.session_id

api/core/ops/langsmith_trace/langsmith_trace.py

@@ -262,7 +262,7 @@ class LangSmithDataTrace(BaseTraceInstance):
 
         if message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 end_user_id = end_user_data.session_id

api/core/ops/opik_trace/opik_trace.py

@@ -284,7 +284,7 @@ class OpikDataTrace(BaseTraceInstance):
 
         if message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 end_user_id = end_user_data.session_id

api/core/ops/ops_trace_manager.py

@@ -226,7 +226,7 @@ class OpsTraceManager:
             return None
 
         # decrypt_token
-        app = db.session.query(App).filter(App.id == app_id).first()
+        app = db.session.query(App).where(App.id == app_id).first()
         if not app:
             raise ValueError("App not found")
 
@@ -253,7 +253,7 @@ class OpsTraceManager:
         if app_id is None:
             return None
 
-        app: Optional[App] = db.session.query(App).filter(App.id == app_id).first()
+        app: Optional[App] = db.session.query(App).where(App.id == app_id).first()
 
         if app is None:
             return None
@@ -293,11 +293,11 @@ class OpsTraceManager:
     @classmethod
     def get_app_config_through_message_id(cls, message_id: str):
         app_model_config = None
-        message_data = db.session.query(Message).filter(Message.id == message_id).first()
+        message_data = db.session.query(Message).where(Message.id == message_id).first()
         if not message_data:
             return None
         conversation_id = message_data.conversation_id
-        conversation_data = db.session.query(Conversation).filter(Conversation.id == conversation_id).first()
+        conversation_data = db.session.query(Conversation).where(Conversation.id == conversation_id).first()
         if not conversation_data:
             return None
 
@@ -331,7 +331,7 @@ class OpsTraceManager:
             if tracing_provider is not None:
                 raise ValueError(f"Invalid tracing provider: {tracing_provider}")
 
-        app_config: Optional[App] = db.session.query(App).filter(App.id == app_id).first()
+        app_config: Optional[App] = db.session.query(App).where(App.id == app_id).first()
         if not app_config:
             raise ValueError("App not found")
         app_config.tracing = json.dumps(
@@ -349,7 +349,7 @@ class OpsTraceManager:
         :param app_id: app id
         :return:
         """
-        app: Optional[App] = db.session.query(App).filter(App.id == app_id).first()
+        app: Optional[App] = db.session.query(App).where(App.id == app_id).first()
         if not app:
             raise ValueError("App not found")
         if not app.tracing:

api/core/ops/utils.py

@@ -22,7 +22,7 @@ def filter_none_values(data: dict):
 
 
 def get_message_data(message_id: str):
-    return db.session.scalar(select(Message).filter(Message.id == message_id))
+    return db.session.scalar(select(Message).where(Message.id == message_id))
 
 
 @contextmanager

api/core/ops/weave_trace/weave_trace.py

@@ -235,7 +235,7 @@ class WeaveDataTrace(BaseTraceInstance):
 
         if message_data.from_end_user_id:
             end_user_data: Optional[EndUser] = (
-                db.session.query(EndUser).filter(EndUser.id == message_data.from_end_user_id).first()
+                db.session.query(EndUser).where(EndUser.id == message_data.from_end_user_id).first()
             )
             if end_user_data is not None:
                 end_user_id = end_user_data.session_id

api/core/plugin/backwards_invocation/app.py

@@ -193,9 +193,9 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
         get the user by user id
         """
 
-        user = db.session.query(EndUser).filter(EndUser.id == user_id).first()
+        user = db.session.query(EndUser).where(EndUser.id == user_id).first()
         if not user:
-            user = db.session.query(Account).filter(Account.id == user_id).first()
+            user = db.session.query(Account).where(Account.id == user_id).first()
 
         if not user:
             raise ValueError("user not found")
@@ -208,7 +208,7 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
         get app
         """
         try:
-            app = db.session.query(App).filter(App.id == app_id).filter(App.tenant_id == tenant_id).first()
+            app = db.session.query(App).where(App.id == app_id).where(App.tenant_id == tenant_id).first()
         except Exception:
             raise ValueError("app not found")
 

api/core/rag/datasource/keyword/jieba/jieba.py

@@ -93,7 +93,7 @@ class Jieba(BaseKeyword):
 
         documents = []
         for chunk_index in sorted_chunk_indices:
-            segment_query = db.session.query(DocumentSegment).filter(
+            segment_query = db.session.query(DocumentSegment).where(
                 DocumentSegment.dataset_id == self.dataset.id, DocumentSegment.index_node_id == chunk_index
             )
             if document_ids_filter:

api/core/rag/datasource/retrieval_service.py

@@ -127,7 +127,7 @@ class RetrievalService:
         external_retrieval_model: Optional[dict] = None,
         metadata_filtering_conditions: Optional[dict] = None,
     ):
-        dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
         if not dataset:
             return []
         metadata_condition = (
@@ -145,7 +145,7 @@ class RetrievalService:
     @classmethod
     def _get_dataset(cls, dataset_id: str) -> Optional[Dataset]:
         with Session(db.engine) as session:
-            return session.query(Dataset).filter(Dataset.id == dataset_id).first()
+            return session.query(Dataset).where(Dataset.id == dataset_id).first()
 
     @classmethod
     def keyword_search(
@@ -318,7 +318,7 @@ class RetrievalService:
                     child_index_node_id = document.metadata.get("doc_id")
 
                     child_chunk = (
-                        db.session.query(ChildChunk).filter(ChildChunk.index_node_id == child_index_node_id).first()
+                        db.session.query(ChildChunk).where(ChildChunk.index_node_id == child_index_node_id).first()
                     )
 
                     if not child_chunk:

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

@@ -418,7 +418,7 @@ class TidbOnQdrantVector(BaseVector):
 class TidbOnQdrantVectorFactory(AbstractVectorFactory):
     def init_vector(self, dataset: Dataset, attributes: list, embeddings: Embeddings) -> TidbOnQdrantVector:
         tidb_auth_binding = (
-            db.session.query(TidbAuthBinding).filter(TidbAuthBinding.tenant_id == dataset.tenant_id).one_or_none()
+            db.session.query(TidbAuthBinding).where(TidbAuthBinding.tenant_id == dataset.tenant_id).one_or_none()
         )
         if not tidb_auth_binding:
             with redis_client.lock("create_tidb_serverless_cluster_lock", timeout=900):

api/core/rag/docstore/dataset_docstore.py

@@ -42,7 +42,7 @@ class DatasetDocumentStore:
     @property
     def docs(self) -> dict[str, Document]:
         document_segments = (
-            db.session.query(DocumentSegment).filter(DocumentSegment.dataset_id == self._dataset.id).all()
+            db.session.query(DocumentSegment).where(DocumentSegment.dataset_id == self._dataset.id).all()
         )
 
         output = {}
@@ -147,7 +147,7 @@ class DatasetDocumentStore:
                 segment_document.tokens = tokens
                 if save_child and doc.children:
                     # delete the existing child chunks
-                    db.session.query(ChildChunk).filter(
+                    db.session.query(ChildChunk).where(
                         ChildChunk.tenant_id == self._dataset.tenant_id,
                         ChildChunk.dataset_id == self._dataset.id,
                         ChildChunk.document_id == self._document_id,

api/core/rag/index_processor/processor/parent_child_index_processor.py

@@ -128,7 +128,7 @@ class ParentChildIndexProcessor(BaseIndexProcessor):
                 child_node_ids = [child_node_id[0] for child_node_id in child_node_ids]
                 vector.delete_by_ids(child_node_ids)
                 if delete_child_chunks:
-                    db.session.query(ChildChunk).filter(
+                    db.session.query(ChildChunk).where(
                         ChildChunk.dataset_id == dataset.id, ChildChunk.index_node_id.in_(child_node_ids)
                     ).delete()
                     db.session.commit()
@@ -136,7 +136,7 @@ class ParentChildIndexProcessor(BaseIndexProcessor):
                 vector.delete()
 
                 if delete_child_chunks:
-                    db.session.query(ChildChunk).filter(ChildChunk.dataset_id == dataset.id).delete()
+                    db.session.query(ChildChunk).where(ChildChunk.dataset_id == dataset.id).delete()
                     db.session.commit()
 
     def retrieve(

api/core/rag/retrieval/dataset_retrieval.py

@@ -135,7 +135,7 @@ class DatasetRetrieval:
         available_datasets = []
         for dataset_id in dataset_ids:
             # get dataset from dataset id
-            dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+            dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
             # pass if dataset is not available
             if not dataset:
@@ -327,7 +327,7 @@ class DatasetRetrieval:
 
         if dataset_id:
             # get retrieval model config
-            dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+            dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
             if dataset:
                 results = []
                 if dataset.provider == "external":
@@ -541,7 +541,7 @@ class DatasetRetrieval:
                             )
                             db.session.commit()
                     else:
-                        query = db.session.query(DocumentSegment).filter(
+                        query = db.session.query(DocumentSegment).where(
                             DocumentSegment.index_node_id == document.metadata["doc_id"]
                         )
 
@@ -600,7 +600,7 @@ class DatasetRetrieval:
     ):
         with flask_app.app_context():
             with Session(db.engine) as session:
-                dataset = session.query(Dataset).filter(Dataset.id == dataset_id).first()
+                dataset = session.query(Dataset).where(Dataset.id == dataset_id).first()
 
             if not dataset:
                 return []
@@ -685,7 +685,7 @@ class DatasetRetrieval:
         available_datasets = []
         for dataset_id in dataset_ids:
             # get dataset from dataset id
-            dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+            dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
 
             # pass if dataset is not available
             if not dataset:
@@ -862,7 +862,7 @@ class DatasetRetrieval:
         metadata_filtering_conditions: Optional[MetadataFilteringCondition],
         inputs: dict,
     ) -> tuple[Optional[dict[str, list[str]]], Optional[MetadataCondition]]:
-        document_query = db.session.query(DatasetDocument).filter(
+        document_query = db.session.query(DatasetDocument).where(
             DatasetDocument.dataset_id.in_(dataset_ids),
             DatasetDocument.indexing_status == "completed",
             DatasetDocument.enabled == True,
@@ -958,7 +958,7 @@ class DatasetRetrieval:
         self, dataset_ids: list, query: str, tenant_id: str, user_id: str, metadata_model_config: ModelConfig
     ) -> Optional[list[dict[str, Any]]]:
         # get all metadata field
-        metadata_fields = db.session.query(DatasetMetadata).filter(DatasetMetadata.dataset_id.in_(dataset_ids)).all()
+        metadata_fields = db.session.query(DatasetMetadata).where(DatasetMetadata.dataset_id.in_(dataset_ids)).all()
         all_metadata_fields = [metadata_field.name for metadata_field in metadata_fields]
         # get metadata model config
         if metadata_model_config is None:

api/core/tools/tool_label_manager.py

@@ -29,7 +29,7 @@ class ToolLabelManager:
             raise ValueError("Unsupported tool type")
 
         # delete old labels
-        db.session.query(ToolLabelBinding).filter(ToolLabelBinding.tool_id == provider_id).delete()
+        db.session.query(ToolLabelBinding).where(ToolLabelBinding.tool_id == provider_id).delete()
 
         # insert new labels
         for label in labels:
@@ -90,7 +90,7 @@ class ToolLabelManager:
             provider_ids.append(controller.provider_id)
 
         labels: list[ToolLabelBinding] = (
-            db.session.query(ToolLabelBinding).filter(ToolLabelBinding.tool_id.in_(provider_ids)).all()
+            db.session.query(ToolLabelBinding).where(ToolLabelBinding.tool_id.in_(provider_ids)).all()
         )
 
         tool_labels: dict[str, list[str]] = {label.tool_id: [] for label in labels}

api/core/tools/tool_manager.py

@@ -616,7 +616,7 @@ class ToolManager:
                 ORDER BY tenant_id, provider, is_default DESC, created_at DESC
                 """
         ids = [row.id for row in db.session.execute(db.text(sql), {"tenant_id": tenant_id}).all()]
-        return db.session.query(BuiltinToolProvider).filter(BuiltinToolProvider.id.in_(ids)).all()
+        return db.session.query(BuiltinToolProvider).where(BuiltinToolProvider.id.in_(ids)).all()
 
     @classmethod
     def list_providers_from_api(
@@ -664,7 +664,7 @@ class ToolManager:
             # get db api providers
             if "api" in filters:
                 db_api_providers: list[ApiToolProvider] = (
-                    db.session.query(ApiToolProvider).filter(ApiToolProvider.tenant_id == tenant_id).all()
+                    db.session.query(ApiToolProvider).where(ApiToolProvider.tenant_id == tenant_id).all()
                 )
 
                 api_provider_controllers: list[dict[str, Any]] = [
@@ -687,7 +687,7 @@ class ToolManager:
             if "workflow" in filters:
                 # get workflow providers
                 workflow_providers: list[WorkflowToolProvider] = (
-                    db.session.query(WorkflowToolProvider).filter(WorkflowToolProvider.tenant_id == tenant_id).all()
+                    db.session.query(WorkflowToolProvider).where(WorkflowToolProvider.tenant_id == tenant_id).all()
                 )
 
                 workflow_provider_controllers: list[WorkflowToolProviderController] = []

api/core/tools/utils/dataset_retriever/dataset_multi_retriever_tool.py

@@ -163,7 +163,7 @@ class DatasetMultiRetrieverTool(DatasetRetrieverBaseTool):
     ):
         with flask_app.app_context():
             dataset = (
-                db.session.query(Dataset).filter(Dataset.tenant_id == self.tenant_id, Dataset.id == dataset_id).first()
+                db.session.query(Dataset).where(Dataset.tenant_id == self.tenant_id, Dataset.id == dataset_id).first()
             )
 
             if not dataset:

api/core/tools/utils/dataset_retriever/dataset_retriever_tool.py

@@ -57,7 +57,7 @@ class DatasetRetrieverTool(DatasetRetrieverBaseTool):
 
     def _run(self, query: str) -> str:
         dataset = (
-            db.session.query(Dataset).filter(Dataset.tenant_id == self.tenant_id, Dataset.id == self.dataset_id).first()
+            db.session.query(Dataset).where(Dataset.tenant_id == self.tenant_id, Dataset.id == self.dataset_id).first()
         )
 
         if not dataset:

api/core/tools/workflow_as_tool/tool.py

@@ -147,7 +147,7 @@ class WorkflowTool(Tool):
                 .first()
             )
         else:
-            workflow = db.session.query(Workflow).filter(Workflow.app_id == app_id, Workflow.version == version).first()
+            workflow = db.session.query(Workflow).where(Workflow.app_id == app_id, Workflow.version == version).first()
 
         if not workflow:
             raise ValueError("workflow not found or not published")
@@ -158,7 +158,7 @@ class WorkflowTool(Tool):
         """
         get the app by app id
         """
-        app = db.session.query(App).filter(App.id == app_id).first()
+        app = db.session.query(App).where(App.id == app_id).first()
         if not app:
             raise ValueError("app not found")
 

api/core/workflow/nodes/knowledge_retrieval/knowledge_retrieval_node.py

@@ -415,7 +415,7 @@ class KnowledgeRetrievalNode(BaseNode):
     def _get_metadata_filter_condition(
         self, dataset_ids: list, query: str, node_data: KnowledgeRetrievalNodeData
     ) -> tuple[Optional[dict[str, list[str]]], Optional[MetadataCondition]]:
-        document_query = db.session.query(Document).filter(
+        document_query = db.session.query(Document).where(
             Document.dataset_id.in_(dataset_ids),
             Document.indexing_status == "completed",
             Document.enabled == True,
@@ -507,7 +507,7 @@ class KnowledgeRetrievalNode(BaseNode):
         self, dataset_ids: list, query: str, node_data: KnowledgeRetrievalNodeData
     ) -> list[dict[str, Any]]:
         # get all metadata field
-        metadata_fields = db.session.query(DatasetMetadata).filter(DatasetMetadata.dataset_id.in_(dataset_ids)).all()
+        metadata_fields = db.session.query(DatasetMetadata).where(DatasetMetadata.dataset_id.in_(dataset_ids)).all()
         all_metadata_fields = [metadata_field.name for metadata_field in metadata_fields]
         if node_data.metadata_model_config is None:
             raise ValueError("metadata_model_config is required")

api/events/event_handlers/update_app_dataset_join_when_app_model_config_updated.py

@@ -13,7 +13,7 @@ def handle(sender, **kwargs):
 
     dataset_ids = get_dataset_ids_from_model_config(app_model_config)
 
-    app_dataset_joins = db.session.query(AppDatasetJoin).filter(AppDatasetJoin.app_id == app.id).all()
+    app_dataset_joins = db.session.query(AppDatasetJoin).where(AppDatasetJoin.app_id == app.id).all()
 
     removed_dataset_ids: set[str] = set()
     if not app_dataset_joins:
@@ -27,7 +27,7 @@ def handle(sender, **kwargs):
 
     if removed_dataset_ids:
         for dataset_id in removed_dataset_ids:
-            db.session.query(AppDatasetJoin).filter(
+            db.session.query(AppDatasetJoin).where(
                 AppDatasetJoin.app_id == app.id, AppDatasetJoin.dataset_id == dataset_id
             ).delete()
 

api/events/event_handlers/update_app_dataset_join_when_app_published_workflow_updated.py

@@ -15,7 +15,7 @@ def handle(sender, **kwargs):
     published_workflow = cast(Workflow, published_workflow)
 
     dataset_ids = get_dataset_ids_from_workflow(published_workflow)
-    app_dataset_joins = db.session.query(AppDatasetJoin).filter(AppDatasetJoin.app_id == app.id).all()
+    app_dataset_joins = db.session.query(AppDatasetJoin).where(AppDatasetJoin.app_id == app.id).all()
 
     removed_dataset_ids: set[str] = set()
     if not app_dataset_joins:
@@ -29,7 +29,7 @@ def handle(sender, **kwargs):
 
     if removed_dataset_ids:
         for dataset_id in removed_dataset_ids:
-            db.session.query(AppDatasetJoin).filter(
+            db.session.query(AppDatasetJoin).where(
                 AppDatasetJoin.app_id == app.id, AppDatasetJoin.dataset_id == dataset_id
             ).delete()
 

api/extensions/ext_login.py

@@ -70,7 +70,7 @@ def load_user_from_request(request_from_flask_login):
         end_user_id = decoded.get("end_user_id")
         if not end_user_id:
             raise Unauthorized("Invalid Authorization token.")
-        end_user = db.session.query(EndUser).filter(EndUser.id == decoded["end_user_id"]).first()
+        end_user = db.session.query(EndUser).where(EndUser.id == decoded["end_user_id"]).first()
         if not end_user:
             raise NotFound("End user not found.")
         return end_user
@@ -78,7 +78,7 @@ def load_user_from_request(request_from_flask_login):
         server_code = request.view_args.get("server_code") if request.view_args else None
         if not server_code:
             raise Unauthorized("Invalid Authorization token.")
-        app_mcp_server = db.session.query(AppMCPServer).filter(AppMCPServer.server_code == server_code).first()
+        app_mcp_server = db.session.query(AppMCPServer).where(AppMCPServer.server_code == server_code).first()
         if not app_mcp_server:
             raise NotFound("App MCP server not found.")
         end_user = (

api/factories/file_factory.py

@@ -262,7 +262,7 @@ def _build_from_tool_file(
     strict_type_validation: bool = False,
 ) -> File:
     tool_file = db.session.scalar(
-        select(ToolFile).filter(
+        select(ToolFile).where(
             ToolFile.id == mapping.get("tool_file_id"),
             ToolFile.tenant_id == tenant_id,
         )

api/models/account.py

@@ -167,7 +167,7 @@ class Account(UserMixin, Base):
             .one_or_none()
         )
         if account_integrate:
-            return db.session.query(Account).filter(Account.id == account_integrate.account_id).one_or_none()
+            return db.session.query(Account).where(Account.id == account_integrate.account_id).one_or_none()
         return None
 
     # check current_user.current_tenant.current_role in ['admin', 'owner']

api/models/dataset.py

@@ -68,7 +68,7 @@ class Dataset(Base):
     @property
     def dataset_keyword_table(self):
         dataset_keyword_table = (
-            db.session.query(DatasetKeywordTable).filter(DatasetKeywordTable.dataset_id == self.id).first()
+            db.session.query(DatasetKeywordTable).where(DatasetKeywordTable.dataset_id == self.id).first()
         )
         if dataset_keyword_table:
             return dataset_keyword_table
@@ -110,7 +110,7 @@ class Dataset(Base):
 
     @property
     def document_count(self):
-        return db.session.query(func.count(Document.id)).filter(Document.dataset_id == self.id).scalar()
+        return db.session.query(func.count(Document.id)).where(Document.dataset_id == self.id).scalar()
 
     @property
     def available_document_count(self):
@@ -148,7 +148,7 @@ class Dataset(Base):
 
     @property
     def doc_form(self):
-        document = db.session.query(Document).filter(Document.dataset_id == self.id).first()
+        document = db.session.query(Document).where(Document.dataset_id == self.id).first()
         if document:
             return document.doc_form
         return None
@@ -185,7 +185,7 @@ class Dataset(Base):
         if self.provider != "external":
             return None
         external_knowledge_binding = (
-            db.session.query(ExternalKnowledgeBindings).filter(ExternalKnowledgeBindings.dataset_id == self.id).first()
+            db.session.query(ExternalKnowledgeBindings).where(ExternalKnowledgeBindings.dataset_id == self.id).first()
         )
         if not external_knowledge_binding:
             return None
@@ -205,7 +205,7 @@ class Dataset(Base):
 
     @property
     def doc_metadata(self):
-        dataset_metadatas = db.session.query(DatasetMetadata).filter(DatasetMetadata.dataset_id == self.id).all()
+        dataset_metadatas = db.session.query(DatasetMetadata).where(DatasetMetadata.dataset_id == self.id).all()
 
         doc_metadata = [
             {
@@ -441,11 +441,11 @@ class Document(Base):
 
     @property
     def dataset(self):
-        return db.session.query(Dataset).filter(Dataset.id == self.dataset_id).one_or_none()
+        return db.session.query(Dataset).where(Dataset.id == self.dataset_id).one_or_none()
 
     @property
     def segment_count(self):
-        return db.session.query(DocumentSegment).filter(DocumentSegment.document_id == self.id).count()
+        return db.session.query(DocumentSegment).where(DocumentSegment.document_id == self.id).count()
 
     @property
     def hit_count(self):
@@ -458,7 +458,7 @@ class Document(Base):
 
     @property
     def uploader(self):
-        user = db.session.query(Account).filter(Account.id == self.created_by).first()
+        user = db.session.query(Account).where(Account.id == self.created_by).first()
         return user.name if user else None
 
     @property
@@ -687,11 +687,11 @@ class DocumentSegment(Base):
 
     @property
     def dataset(self):
-        return db.session.scalars(select(Dataset).filter(Dataset.id == self.dataset_id).limit(1)).first()
+        return db.session.scalars(select(Dataset).where(Dataset.id == self.dataset_id).limit(1)).first()
 
     @property
     def document(self):
-        return db.session.scalars(select(Document).filter(Document.id == self.document_id).limit(1)).first()
+        return db.session.scalars(select(Document).where(Document.id == self.document_id).limit(1)).first()
 
     @property
     def previous_segment(self):
@@ -825,15 +825,15 @@ class ChildChunk(Base):
 
     @property
     def dataset(self):
-        return db.session.query(Dataset).filter(Dataset.id == self.dataset_id).first()
+        return db.session.query(Dataset).where(Dataset.id == self.dataset_id).first()
 
     @property
     def document(self):
-        return db.session.query(Document).filter(Document.id == self.document_id).first()
+        return db.session.query(Document).where(Document.id == self.document_id).first()
 
     @property
     def segment(self):
-        return db.session.query(DocumentSegment).filter(DocumentSegment.id == self.segment_id).first()
+        return db.session.query(DocumentSegment).where(DocumentSegment.id == self.segment_id).first()
 
 
 class AppDatasetJoin(Base):
@@ -1048,7 +1048,7 @@ class ExternalKnowledgeApis(Base):
             .all()
         )
         dataset_ids = [binding.dataset_id for binding in external_knowledge_bindings]
-        datasets = db.session.query(Dataset).filter(Dataset.id.in_(dataset_ids)).all()
+        datasets = db.session.query(Dataset).where(Dataset.id.in_(dataset_ids)).all()
         dataset_bindings = []
         for dataset in datasets:
             dataset_bindings.append({"id": dataset.id, "name": dataset.name})

api/models/model.py

@@ -113,13 +113,13 @@ class App(Base):
 
     @property
     def site(self):
-        site = db.session.query(Site).filter(Site.app_id == self.id).first()
+        site = db.session.query(Site).where(Site.app_id == self.id).first()
         return site
 
     @property
     def app_model_config(self):
         if self.app_model_config_id:
-            return db.session.query(AppModelConfig).filter(AppModelConfig.id == self.app_model_config_id).first()
+            return db.session.query(AppModelConfig).where(AppModelConfig.id == self.app_model_config_id).first()
 
         return None
 
@@ -128,7 +128,7 @@ class App(Base):
         if self.workflow_id:
             from .workflow import Workflow
 
-            return db.session.query(Workflow).filter(Workflow.id == self.workflow_id).first()
+            return db.session.query(Workflow).where(Workflow.id == self.workflow_id).first()
 
         return None
 
@@ -138,7 +138,7 @@ class App(Base):
 
     @property
     def tenant(self):
-        tenant = db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+        tenant = db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
         return tenant
 
     @property
@@ -296,7 +296,7 @@ class App(Base):
     @property
     def author_name(self):
         if self.created_by:
-            account = db.session.query(Account).filter(Account.id == self.created_by).first()
+            account = db.session.query(Account).where(Account.id == self.created_by).first()
             if account:
                 return account.name
 
@@ -338,7 +338,7 @@ class AppModelConfig(Base):
 
     @property
     def app(self):
-        app = db.session.query(App).filter(App.id == self.app_id).first()
+        app = db.session.query(App).where(App.id == self.app_id).first()
         return app
 
     @property
@@ -372,7 +372,7 @@ class AppModelConfig(Base):
     @property
     def annotation_reply_dict(self) -> dict:
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == self.app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == self.app_id).first()
         )
         if annotation_setting:
             collection_binding_detail = annotation_setting.collection_binding_detail
@@ -577,7 +577,7 @@ class RecommendedApp(Base):
 
     @property
     def app(self):
-        app = db.session.query(App).filter(App.id == self.app_id).first()
+        app = db.session.query(App).where(App.id == self.app_id).first()
         return app
 
 
@@ -601,12 +601,12 @@ class InstalledApp(Base):
 
     @property
     def app(self):
-        app = db.session.query(App).filter(App.id == self.app_id).first()
+        app = db.session.query(App).where(App.id == self.app_id).first()
         return app
 
     @property
     def tenant(self):
-        tenant = db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+        tenant = db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
         return tenant
 
 
@@ -714,7 +714,7 @@ class Conversation(Base):
                     model_config["configs"] = override_model_configs
             else:
                 app_model_config = (
-                    db.session.query(AppModelConfig).filter(AppModelConfig.id == self.app_model_config_id).first()
+                    db.session.query(AppModelConfig).where(AppModelConfig.id == self.app_model_config_id).first()
                 )
                 if app_model_config:
                     model_config = app_model_config.to_dict()
@@ -737,15 +737,15 @@ class Conversation(Base):
 
     @property
     def annotated(self):
-        return db.session.query(MessageAnnotation).filter(MessageAnnotation.conversation_id == self.id).count() > 0
+        return db.session.query(MessageAnnotation).where(MessageAnnotation.conversation_id == self.id).count() > 0
 
     @property
     def annotation(self):
-        return db.session.query(MessageAnnotation).filter(MessageAnnotation.conversation_id == self.id).first()
+        return db.session.query(MessageAnnotation).where(MessageAnnotation.conversation_id == self.id).first()
 
     @property
     def message_count(self):
-        return db.session.query(Message).filter(Message.conversation_id == self.id).count()
+        return db.session.query(Message).where(Message.conversation_id == self.id).count()
 
     @property
     def user_feedback_stats(self):
@@ -797,7 +797,7 @@ class Conversation(Base):
 
     @property
     def status_count(self):
-        messages = db.session.query(Message).filter(Message.conversation_id == self.id).all()
+        messages = db.session.query(Message).where(Message.conversation_id == self.id).all()
         status_counts = {
             WorkflowExecutionStatus.RUNNING: 0,
             WorkflowExecutionStatus.SUCCEEDED: 0,
@@ -831,12 +831,12 @@ class Conversation(Base):
 
     @property
     def app(self):
-        return db.session.query(App).filter(App.id == self.app_id).first()
+        return db.session.query(App).where(App.id == self.app_id).first()
 
     @property
     def from_end_user_session_id(self):
         if self.from_end_user_id:
-            end_user = db.session.query(EndUser).filter(EndUser.id == self.from_end_user_id).first()
+            end_user = db.session.query(EndUser).where(EndUser.id == self.from_end_user_id).first()
             if end_user:
                 return end_user.session_id
 
@@ -845,7 +845,7 @@ class Conversation(Base):
     @property
     def from_account_name(self):
         if self.from_account_id:
-            account = db.session.query(Account).filter(Account.id == self.from_account_id).first()
+            account = db.session.query(Account).where(Account.id == self.from_account_id).first()
             if account:
                 return account.name
 
@@ -1056,18 +1056,18 @@ class Message(Base):
 
     @property
     def feedbacks(self):
-        feedbacks = db.session.query(MessageFeedback).filter(MessageFeedback.message_id == self.id).all()
+        feedbacks = db.session.query(MessageFeedback).where(MessageFeedback.message_id == self.id).all()
         return feedbacks
 
     @property
     def annotation(self):
-        annotation = db.session.query(MessageAnnotation).filter(MessageAnnotation.message_id == self.id).first()
+        annotation = db.session.query(MessageAnnotation).where(MessageAnnotation.message_id == self.id).first()
         return annotation
 
     @property
     def annotation_hit_history(self):
         annotation_history = (
-            db.session.query(AppAnnotationHitHistory).filter(AppAnnotationHitHistory.message_id == self.id).first()
+            db.session.query(AppAnnotationHitHistory).where(AppAnnotationHitHistory.message_id == self.id).first()
         )
         if annotation_history:
             annotation = (
@@ -1080,10 +1080,10 @@ class Message(Base):
 
     @property
     def app_model_config(self):
-        conversation = db.session.query(Conversation).filter(Conversation.id == self.conversation_id).first()
+        conversation = db.session.query(Conversation).where(Conversation.id == self.conversation_id).first()
         if conversation:
             return (
-                db.session.query(AppModelConfig).filter(AppModelConfig.id == conversation.app_model_config_id).first()
+                db.session.query(AppModelConfig).where(AppModelConfig.id == conversation.app_model_config_id).first()
             )
 
         return None
@@ -1113,8 +1113,8 @@ class Message(Base):
     def message_files(self):
         from factories import file_factory
 
-        message_files = db.session.query(MessageFile).filter(MessageFile.message_id == self.id).all()
-        current_app = db.session.query(App).filter(App.id == self.app_id).first()
+        message_files = db.session.query(MessageFile).where(MessageFile.message_id == self.id).all()
+        current_app = db.session.query(App).where(App.id == self.app_id).first()
         if not current_app:
             raise ValueError(f"App {self.app_id} not found")
 
@@ -1178,7 +1178,7 @@ class Message(Base):
         if self.workflow_run_id:
             from .workflow import WorkflowRun
 
-            return db.session.query(WorkflowRun).filter(WorkflowRun.id == self.workflow_run_id).first()
+            return db.session.query(WorkflowRun).where(WorkflowRun.id == self.workflow_run_id).first()
 
         return None
 
@@ -1253,7 +1253,7 @@ class MessageFeedback(Base):
 
     @property
     def from_account(self):
-        account = db.session.query(Account).filter(Account.id == self.from_account_id).first()
+        account = db.session.query(Account).where(Account.id == self.from_account_id).first()
         return account
 
     def to_dict(self):
@@ -1335,12 +1335,12 @@ class MessageAnnotation(Base):
 
     @property
     def account(self):
-        account = db.session.query(Account).filter(Account.id == self.account_id).first()
+        account = db.session.query(Account).where(Account.id == self.account_id).first()
         return account
 
     @property
     def annotation_create_account(self):
-        account = db.session.query(Account).filter(Account.id == self.account_id).first()
+        account = db.session.query(Account).where(Account.id == self.account_id).first()
         return account
 
 
@@ -1378,7 +1378,7 @@ class AppAnnotationHitHistory(Base):
 
     @property
     def annotation_create_account(self):
-        account = db.session.query(Account).filter(Account.id == self.account_id).first()
+        account = db.session.query(Account).where(Account.id == self.account_id).first()
         return account
 
 
@@ -1470,7 +1470,7 @@ class AppMCPServer(Base):
     def generate_server_code(n):
         while True:
             result = generate_string(n)
-            while db.session.query(AppMCPServer).filter(AppMCPServer.server_code == result).count() > 0:
+            while db.session.query(AppMCPServer).where(AppMCPServer.server_code == result).count() > 0:
                 result = generate_string(n)
 
             return result
@@ -1527,7 +1527,7 @@ class Site(Base):
     def generate_code(n):
         while True:
             result = generate_string(n)
-            while db.session.query(Site).filter(Site.code == result).count() > 0:
+            while db.session.query(Site).where(Site.code == result).count() > 0:
                 result = generate_string(n)
 
             return result
@@ -1558,7 +1558,7 @@ class ApiToken(Base):
     def generate_api_key(prefix, n):
         while True:
             result = prefix + generate_string(n)
-            if db.session.query(ApiToken).filter(ApiToken.token == result).count() > 0:
+            if db.session.query(ApiToken).where(ApiToken.token == result).count() > 0:
                 continue
             return result
 

api/models/tools.py

@@ -153,11 +153,11 @@ class ApiToolProvider(Base):
     def user(self) -> Account | None:
         if not self.user_id:
             return None
-        return db.session.query(Account).filter(Account.id == self.user_id).first()
+        return db.session.query(Account).where(Account.id == self.user_id).first()
 
     @property
     def tenant(self) -> Tenant | None:
-        return db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
 
 
 class ToolLabelBinding(Base):
@@ -223,11 +223,11 @@ class WorkflowToolProvider(Base):
 
     @property
     def user(self) -> Account | None:
-        return db.session.query(Account).filter(Account.id == self.user_id).first()
+        return db.session.query(Account).where(Account.id == self.user_id).first()
 
     @property
     def tenant(self) -> Tenant | None:
-        return db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
 
     @property
     def parameter_configurations(self) -> list[WorkflowToolParameterConfiguration]:
@@ -235,7 +235,7 @@ class WorkflowToolProvider(Base):
 
     @property
     def app(self) -> App | None:
-        return db.session.query(App).filter(App.id == self.app_id).first()
+        return db.session.query(App).where(App.id == self.app_id).first()
 
 
 class MCPToolProvider(Base):
@@ -280,11 +280,11 @@ class MCPToolProvider(Base):
     )
 
     def load_user(self) -> Account | None:
-        return db.session.query(Account).filter(Account.id == self.user_id).first()
+        return db.session.query(Account).where(Account.id == self.user_id).first()
 
     @property
     def tenant(self) -> Tenant | None:
-        return db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
+        return db.session.query(Tenant).where(Tenant.id == self.tenant_id).first()
 
     @property
     def credentials(self) -> dict:

api/models/web.py

@@ -26,7 +26,7 @@ class SavedMessage(Base):
 
     @property
     def message(self):
-        return db.session.query(Message).filter(Message.id == self.message_id).first()
+        return db.session.query(Message).where(Message.id == self.message_id).first()
 
 
 class PinnedConversation(Base):

api/models/workflow.py

@@ -549,12 +549,12 @@ class WorkflowRun(Base):
         from models.model import Message
 
         return (
-            db.session.query(Message).filter(Message.app_id == self.app_id, Message.workflow_run_id == self.id).first()
+            db.session.query(Message).where(Message.app_id == self.app_id, Message.workflow_run_id == self.id).first()
         )
 
     @property
     def workflow(self):
-        return db.session.query(Workflow).filter(Workflow.id == self.workflow_id).first()
+        return db.session.query(Workflow).where(Workflow.id == self.workflow_id).first()
 
     def to_dict(self):
         return {

api/schedule/clean_messages.py

@@ -66,25 +66,25 @@ def clean_messages():
                 plan = plan_cache.decode()
             if plan == "sandbox":
                 # clean related message
-                db.session.query(MessageFeedback).filter(MessageFeedback.message_id == message.id).delete(
+                db.session.query(MessageFeedback).where(MessageFeedback.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(MessageAnnotation).filter(MessageAnnotation.message_id == message.id).delete(
+                db.session.query(MessageAnnotation).where(MessageAnnotation.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(MessageChain).filter(MessageChain.message_id == message.id).delete(
+                db.session.query(MessageChain).where(MessageChain.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(MessageAgentThought).filter(MessageAgentThought.message_id == message.id).delete(
+                db.session.query(MessageAgentThought).where(MessageAgentThought.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(MessageFile).filter(MessageFile.message_id == message.id).delete(
+                db.session.query(MessageFile).where(MessageFile.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(SavedMessage).filter(SavedMessage.message_id == message.id).delete(
+                db.session.query(SavedMessage).where(SavedMessage.message_id == message.id).delete(
                     synchronize_session=False
                 )
-                db.session.query(Message).filter(Message.id == message.id).delete()
+                db.session.query(Message).where(Message.id == message.id).delete()
                 db.session.commit()
     end_at = time.perf_counter()
     click.echo(click.style("Cleaned messages from db success latency: {}".format(end_at - start_at), fg="green"))

api/schedule/create_tidb_serverless_task.py

@@ -20,7 +20,7 @@ def create_tidb_serverless_task():
         try:
             # check the number of idle tidb serverless
             idle_tidb_serverless_number = (
-                db.session.query(TidbAuthBinding).filter(TidbAuthBinding.active == False).count()
+                db.session.query(TidbAuthBinding).where(TidbAuthBinding.active == False).count()
             )
             if idle_tidb_serverless_number >= tidb_serverless_number:
                 break

api/schedule/mail_clean_document_notify_task.py

@@ -30,7 +30,7 @@ def mail_clean_document_notify_task():
     # send document clean notify mail
     try:
         dataset_auto_disable_logs = (
-            db.session.query(DatasetAutoDisableLog).filter(DatasetAutoDisableLog.notified == False).all()
+            db.session.query(DatasetAutoDisableLog).where(DatasetAutoDisableLog.notified == False).all()
         )
         # group by tenant_id
         dataset_auto_disable_logs_map: dict[str, list[DatasetAutoDisableLog]] = defaultdict(list)
@@ -45,7 +45,7 @@ def mail_clean_document_notify_task():
             if plan != "sandbox":
                 knowledge_details = []
                 # check tenant
-                tenant = db.session.query(Tenant).filter(Tenant.id == tenant_id).first()
+                tenant = db.session.query(Tenant).where(Tenant.id == tenant_id).first()
                 if not tenant:
                     continue
                 # check current owner
@@ -54,7 +54,7 @@ def mail_clean_document_notify_task():
                 )
                 if not current_owner_join:
                     continue
-                account = db.session.query(Account).filter(Account.id == current_owner_join.account_id).first()
+                account = db.session.query(Account).where(Account.id == current_owner_join.account_id).first()
                 if not account:
                     continue
 
@@ -67,7 +67,7 @@ def mail_clean_document_notify_task():
                     )
 
                 for dataset_id, document_ids in dataset_auto_dataset_map.items():
-                    dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+                    dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
                     if dataset:
                         document_count = len(document_ids)
                         knowledge_details.append(rf"Knowledge base {dataset.name}: {document_count} documents")

api/services/account_service.py

@@ -643,7 +643,7 @@ class AccountService:
                 )
             )
 
-        account = db.session.query(Account).filter(Account.email == email).first()
+        account = db.session.query(Account).where(Account.email == email).first()
         if not account:
             return None
 
@@ -940,7 +940,7 @@ class TenantService:
         if not tenant_account_join:
             raise AccountNotLinkTenantError("Tenant not found or account is not a member of the tenant.")
         else:
-            db.session.query(TenantAccountJoin).filter(
+            db.session.query(TenantAccountJoin).where(
                 TenantAccountJoin.account_id == account.id, TenantAccountJoin.tenant_id != tenant_id
             ).update({"current": False})
             tenant_account_join.current = True

api/services/agent_service.py

@@ -52,11 +52,11 @@ class AgentService:
         if conversation.from_end_user_id:
             # only select name field
             executor = (
-                db.session.query(EndUser, EndUser.name).filter(EndUser.id == conversation.from_end_user_id).first()
+                db.session.query(EndUser, EndUser.name).where(EndUser.id == conversation.from_end_user_id).first()
             )
         else:
             executor = (
-                db.session.query(Account, Account.name).filter(Account.id == conversation.from_account_id).first()
+                db.session.query(Account, Account.name).where(Account.id == conversation.from_account_id).first()
             )
 
         if executor:

api/services/annotation_service.py

@@ -35,7 +35,7 @@ class AppAnnotationService:
         if args.get("message_id"):
             message_id = str(args["message_id"])
             # get message info
-            message = db.session.query(Message).filter(Message.id == message_id, Message.app_id == app.id).first()
+            message = db.session.query(Message).where(Message.id == message_id, Message.app_id == app.id).first()
 
             if not message:
                 raise NotFound("Message Not Exists.")
@@ -62,7 +62,7 @@ class AppAnnotationService:
         db.session.commit()
         # if annotation reply is enabled , add annotation to index
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
         if annotation_setting:
             add_annotation_to_index_task.delay(
@@ -182,7 +182,7 @@ class AppAnnotationService:
         db.session.commit()
         # if annotation reply is enabled , add annotation to index
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
         if annotation_setting:
             add_annotation_to_index_task.delay(
@@ -206,7 +206,7 @@ class AppAnnotationService:
         if not app:
             raise NotFound("App not found")
 
-        annotation = db.session.query(MessageAnnotation).filter(MessageAnnotation.id == annotation_id).first()
+        annotation = db.session.query(MessageAnnotation).where(MessageAnnotation.id == annotation_id).first()
 
         if not annotation:
             raise NotFound("Annotation not found")
@@ -217,7 +217,7 @@ class AppAnnotationService:
         db.session.commit()
         # if annotation reply is enabled , add annotation to index
         app_annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
 
         if app_annotation_setting:
@@ -243,7 +243,7 @@ class AppAnnotationService:
         if not app:
             raise NotFound("App not found")
 
-        annotation = db.session.query(MessageAnnotation).filter(MessageAnnotation.id == annotation_id).first()
+        annotation = db.session.query(MessageAnnotation).where(MessageAnnotation.id == annotation_id).first()
 
         if not annotation:
             raise NotFound("Annotation not found")
@@ -262,7 +262,7 @@ class AppAnnotationService:
         db.session.commit()
         # if annotation reply is enabled , delete annotation index
         app_annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
 
         if app_annotation_setting:
@@ -321,7 +321,7 @@ class AppAnnotationService:
         if not app:
             raise NotFound("App not found")
 
-        annotation = db.session.query(MessageAnnotation).filter(MessageAnnotation.id == annotation_id).first()
+        annotation = db.session.query(MessageAnnotation).where(MessageAnnotation.id == annotation_id).first()
 
         if not annotation:
             raise NotFound("Annotation not found")
@@ -341,7 +341,7 @@ class AppAnnotationService:
 
     @classmethod
     def get_annotation_by_id(cls, annotation_id: str) -> MessageAnnotation | None:
-        annotation = db.session.query(MessageAnnotation).filter(MessageAnnotation.id == annotation_id).first()
+        annotation = db.session.query(MessageAnnotation).where(MessageAnnotation.id == annotation_id).first()
 
         if not annotation:
             return None
@@ -361,7 +361,7 @@ class AppAnnotationService:
         score: float,
     ):
         # add hit count to annotation
-        db.session.query(MessageAnnotation).filter(MessageAnnotation.id == annotation_id).update(
+        db.session.query(MessageAnnotation).where(MessageAnnotation.id == annotation_id).update(
             {MessageAnnotation.hit_count: MessageAnnotation.hit_count + 1}, synchronize_session=False
         )
 
@@ -392,7 +392,7 @@ class AppAnnotationService:
             raise NotFound("App not found")
 
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
         if annotation_setting:
             collection_binding_detail = annotation_setting.collection_binding_detail

api/services/app_service.py

@@ -382,7 +382,7 @@ class AppService:
                 elif provider_type == "api":
                     try:
                         provider: Optional[ApiToolProvider] = (
-                            db.session.query(ApiToolProvider).filter(ApiToolProvider.id == provider_id).first()
+                            db.session.query(ApiToolProvider).where(ApiToolProvider.id == provider_id).first()
                         )
                         if provider is None:
                             raise ValueError(f"provider not found for tool {tool_name}")
@@ -399,7 +399,7 @@ class AppService:
         :param app_id: app id
         :return: app code
         """
-        site = db.session.query(Site).filter(Site.app_id == app_id).first()
+        site = db.session.query(Site).where(Site.app_id == app_id).first()
         if not site:
             raise ValueError(f"App with id {app_id} not found")
         return str(site.code)
@@ -411,7 +411,7 @@ class AppService:
         :param app_code: app code
         :return: app id
         """
-        site = db.session.query(Site).filter(Site.code == app_code).first()
+        site = db.session.query(Site).where(Site.code == app_code).first()
         if not site:
             raise ValueError(f"App with code {app_code} not found")
         return str(site.app_id)

api/services/audio_service.py

@@ -135,7 +135,7 @@ class AudioService:
                 uuid.UUID(message_id)
             except ValueError:
                 return None
-            message = db.session.query(Message).filter(Message.id == message_id).first()
+            message = db.session.query(Message).where(Message.id == message_id).first()
             if message is None:
                 return None
             if message.answer == "" and message.status == MessageStatus.NORMAL:

api/services/clear_free_plan_tenant_expired_logs.py

@@ -24,7 +24,7 @@ class ClearFreePlanTenantExpiredLogs:
     @classmethod
     def process_tenant(cls, flask_app: Flask, tenant_id: str, days: int, batch: int):
         with flask_app.app_context():
-            apps = db.session.query(App).filter(App.tenant_id == tenant_id).all()
+            apps = db.session.query(App).where(App.tenant_id == tenant_id).all()
             app_ids = [app.id for app in apps]
             while True:
                 with Session(db.engine).no_autoflush as session:
@@ -54,7 +54,7 @@ class ClearFreePlanTenantExpiredLogs:
                     message_ids = [message.id for message in messages]
 
                     # delete messages
-                    session.query(Message).filter(
+                    session.query(Message).where(
                         Message.id.in_(message_ids),
                     ).delete(synchronize_session=False)
 
@@ -93,7 +93,7 @@ class ClearFreePlanTenantExpiredLogs:
                     )
 
                     conversation_ids = [conversation.id for conversation in conversations]
-                    session.query(Conversation).filter(
+                    session.query(Conversation).where(
                         Conversation.id.in_(conversation_ids),
                     ).delete(synchronize_session=False)
                     session.commit()

api/services/dataset_service.py

@@ -80,7 +80,7 @@ from tasks.sync_website_document_indexing_task import sync_website_document_inde
 class DatasetService:
     @staticmethod
     def get_datasets(page, per_page, tenant_id=None, user=None, search=None, tag_ids=None, include_all=False):
-        query = select(Dataset).filter(Dataset.tenant_id == tenant_id).order_by(Dataset.created_at.desc())
+        query = select(Dataset).where(Dataset.tenant_id == tenant_id).order_by(Dataset.created_at.desc())
 
         if user:
             # get permitted dataset ids
@@ -158,7 +158,7 @@ class DatasetService:
 
     @staticmethod
     def get_datasets_by_ids(ids, tenant_id):
-        stmt = select(Dataset).filter(Dataset.id.in_(ids), Dataset.tenant_id == tenant_id)
+        stmt = select(Dataset).where(Dataset.id.in_(ids), Dataset.tenant_id == tenant_id)
 
         datasets = db.paginate(select=stmt, page=1, per_page=len(ids), max_per_page=len(ids), error_out=False)
 
@@ -843,7 +843,7 @@ class DocumentService:
     def get_document(dataset_id: str, document_id: Optional[str] = None) -> Optional[Document]:
         if document_id:
             document = (
-                db.session.query(Document).filter(Document.id == document_id, Document.dataset_id == dataset_id).first()
+                db.session.query(Document).where(Document.id == document_id, Document.dataset_id == dataset_id).first()
             )
             return document
         else:
@@ -851,7 +851,7 @@ class DocumentService:
 
     @staticmethod
     def get_document_by_id(document_id: str) -> Optional[Document]:
-        document = db.session.query(Document).filter(Document.id == document_id).first()
+        document = db.session.query(Document).where(Document.id == document_id).first()
 
         return document
 
@@ -922,7 +922,7 @@ class DocumentService:
 
     @staticmethod
     def get_document_file_detail(file_id: str):
-        file_detail = db.session.query(UploadFile).filter(UploadFile.id == file_id).one_or_none()
+        file_detail = db.session.query(UploadFile).where(UploadFile.id == file_id).one_or_none()
         return file_detail
 
     @staticmethod
@@ -950,7 +950,7 @@ class DocumentService:
 
     @staticmethod
     def delete_documents(dataset: Dataset, document_ids: list[str]):
-        documents = db.session.query(Document).filter(Document.id.in_(document_ids)).all()
+        documents = db.session.query(Document).where(Document.id.in_(document_ids)).all()
         file_ids = [
             document.data_source_info_dict["upload_file_id"]
             for document in documents
@@ -2043,7 +2043,7 @@ class SegmentService:
                 segment_document.status = "error"
                 segment_document.error = str(e)
                 db.session.commit()
-            segment = db.session.query(DocumentSegment).filter(DocumentSegment.id == segment_document.id).first()
+            segment = db.session.query(DocumentSegment).where(DocumentSegment.id == segment_document.id).first()
             return segment
 
     @classmethod
@@ -2295,7 +2295,7 @@ class SegmentService:
             segment.status = "error"
             segment.error = str(e)
             db.session.commit()
-        new_segment = db.session.query(DocumentSegment).filter(DocumentSegment.id == segment.id).first()
+        new_segment = db.session.query(DocumentSegment).where(DocumentSegment.id == segment.id).first()
         return new_segment
 
     @classmethod
@@ -2332,7 +2332,7 @@ class SegmentService:
         index_node_ids = [index_node_id[0] for index_node_id in index_node_ids]
 
         delete_segment_from_index_task.delay(index_node_ids, dataset.id, document.id)
-        db.session.query(DocumentSegment).filter(DocumentSegment.id.in_(segment_ids)).delete()
+        db.session.query(DocumentSegment).where(DocumentSegment.id.in_(segment_ids)).delete()
         db.session.commit()
 
     @classmethod
@@ -2594,7 +2594,7 @@ class SegmentService:
         limit: int = 20,
     ):
         """Get segments for a document with optional filtering."""
-        query = select(DocumentSegment).filter(
+        query = select(DocumentSegment).where(
             DocumentSegment.document_id == document_id, DocumentSegment.tenant_id == tenant_id
         )
 
@@ -2615,7 +2615,7 @@ class SegmentService:
     ) -> tuple[DocumentSegment, Document]:
         """Update a segment by its ID with validation and checks."""
         # check dataset
-        dataset = db.session.query(Dataset).filter(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
         if not dataset:
             raise NotFound("Dataset not found.")
 
@@ -2735,7 +2735,7 @@ class DatasetPermissionService:
     @classmethod
     def update_partial_member_list(cls, tenant_id, dataset_id, user_list):
         try:
-            db.session.query(DatasetPermission).filter(DatasetPermission.dataset_id == dataset_id).delete()
+            db.session.query(DatasetPermission).where(DatasetPermission.dataset_id == dataset_id).delete()
             permissions = []
             for user in user_list:
                 permission = DatasetPermission(
@@ -2771,7 +2771,7 @@ class DatasetPermissionService:
     @classmethod
     def clear_partial_member_list(cls, dataset_id):
         try:
-            db.session.query(DatasetPermission).filter(DatasetPermission.dataset_id == dataset_id).delete()
+            db.session.query(DatasetPermission).where(DatasetPermission.dataset_id == dataset_id).delete()
             db.session.commit()
         except Exception as e:
             db.session.rollback()

api/services/file_service.py

@@ -144,7 +144,7 @@ class FileService:
 
     @staticmethod
     def get_file_preview(file_id: str):
-        upload_file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+        upload_file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
 
         if not upload_file:
             raise NotFound("File not found")
@@ -167,7 +167,7 @@ class FileService:
         if not result:
             raise NotFound("File not found or signature is invalid")
 
-        upload_file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+        upload_file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
 
         if not upload_file:
             raise NotFound("File not found or signature is invalid")
@@ -187,7 +187,7 @@ class FileService:
         if not result:
             raise NotFound("File not found or signature is invalid")
 
-        upload_file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+        upload_file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
 
         if not upload_file:
             raise NotFound("File not found or signature is invalid")
@@ -198,7 +198,7 @@ class FileService:
 
     @staticmethod
     def get_public_image_preview(file_id: str):
-        upload_file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+        upload_file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
 
         if not upload_file:
             raise NotFound("File not found or signature is invalid")

api/services/ops_service.py

@@ -25,7 +25,7 @@ class OpsService:
             return None
 
         # decrypt_token and obfuscated_token
-        app = db.session.query(App).filter(App.id == app_id).first()
+        app = db.session.query(App).where(App.id == app_id).first()
         if not app:
             return None
         tenant_id = app.tenant_id
@@ -156,7 +156,7 @@ class OpsService:
             return None
 
         # get tenant id
-        app = db.session.query(App).filter(App.id == app_id).first()
+        app = db.session.query(App).where(App.id == app_id).first()
         if not app:
             return None
         tenant_id = app.tenant_id
@@ -198,7 +198,7 @@ class OpsService:
             return None
 
         # get tenant id
-        app = db.session.query(App).filter(App.id == app_id).first()
+        app = db.session.query(App).where(App.id == app_id).first()
         if not app:
             return None
         tenant_id = app.tenant_id

api/services/plugin/plugin_migration.py

@@ -212,7 +212,7 @@ class PluginMigration:
         Extract tool tables.
         """
         with Session(db.engine) as session:
-            rs = session.query(BuiltinToolProvider).filter(BuiltinToolProvider.tenant_id == tenant_id).all()
+            rs = session.query(BuiltinToolProvider).where(BuiltinToolProvider.tenant_id == tenant_id).all()
             result = []
             for row in rs:
                 result.append(ToolProviderID(row.provider).plugin_id)
@@ -226,7 +226,7 @@ class PluginMigration:
         """
 
         with Session(db.engine) as session:
-            rs = session.query(Workflow).filter(Workflow.tenant_id == tenant_id).all()
+            rs = session.query(Workflow).where(Workflow.tenant_id == tenant_id).all()
             result = []
             for row in rs:
                 graph = row.graph_dict
@@ -249,7 +249,7 @@ class PluginMigration:
         Extract app tables.
         """
         with Session(db.engine) as session:
-            apps = session.query(App).filter(App.tenant_id == tenant_id).all()
+            apps = session.query(App).where(App.tenant_id == tenant_id).all()
             if not apps:
                 return []
 
@@ -257,7 +257,7 @@ class PluginMigration:
                 app.app_model_config_id for app in apps if app.is_agent or app.mode == AppMode.AGENT_CHAT.value
             ]
 
-            rs = session.query(AppModelConfig).filter(AppModelConfig.id.in_(agent_app_model_config_ids)).all()
+            rs = session.query(AppModelConfig).where(AppModelConfig.id.in_(agent_app_model_config_ids)).all()
             result = []
             for row in rs:
                 agent_config = row.agent_mode_dict

api/services/plugin/plugin_permission_service.py

@@ -8,7 +8,7 @@ class PluginPermissionService:
     @staticmethod
     def get_permission(tenant_id: str) -> TenantPluginPermission | None:
         with Session(db.engine) as session:
-            return session.query(TenantPluginPermission).filter(TenantPluginPermission.tenant_id == tenant_id).first()
+            return session.query(TenantPluginPermission).where(TenantPluginPermission.tenant_id == tenant_id).first()
 
     @staticmethod
     def change_permission(
@@ -18,7 +18,7 @@ class PluginPermissionService:
     ):
         with Session(db.engine) as session:
             permission = (
-                session.query(TenantPluginPermission).filter(TenantPluginPermission.tenant_id == tenant_id).first()
+                session.query(TenantPluginPermission).where(TenantPluginPermission.tenant_id == tenant_id).first()
             )
             if not permission:
                 permission = TenantPluginPermission(

api/services/recommend_app/database/database_retrieval.py

@@ -91,7 +91,7 @@ class DatabaseRecommendAppRetrieval(RecommendAppRetrievalBase):
             return None
 
         # get app detail
-        app_model = db.session.query(App).filter(App.id == app_id).first()
+        app_model = db.session.query(App).where(App.id == app_id).first()
         if not app_model or not app_model.is_public:
             return None
 

api/services/tag_service.py

@@ -92,7 +92,7 @@ class TagService:
     def update_tags(args: dict, tag_id: str) -> Tag:
         if TagService.get_tag_by_tag_name(args.get("type", ""), current_user.current_tenant_id, args.get("name", "")):
             raise ValueError("Tag name already exists")
-        tag = db.session.query(Tag).filter(Tag.id == tag_id).first()
+        tag = db.session.query(Tag).where(Tag.id == tag_id).first()
         if not tag:
             raise NotFound("Tag not found")
         tag.name = args["name"]
@@ -101,17 +101,17 @@ class TagService:
 
     @staticmethod
     def get_tag_binding_count(tag_id: str) -> int:
-        count = db.session.query(TagBinding).filter(TagBinding.tag_id == tag_id).count()
+        count = db.session.query(TagBinding).where(TagBinding.tag_id == tag_id).count()
         return count
 
     @staticmethod
     def delete_tag(tag_id: str):
-        tag = db.session.query(Tag).filter(Tag.id == tag_id).first()
+        tag = db.session.query(Tag).where(Tag.id == tag_id).first()
         if not tag:
             raise NotFound("Tag not found")
         db.session.delete(tag)
         # delete tag binding
-        tag_bindings = db.session.query(TagBinding).filter(TagBinding.tag_id == tag_id).all()
+        tag_bindings = db.session.query(TagBinding).where(TagBinding.tag_id == tag_id).all()
         if tag_bindings:
             for tag_binding in tag_bindings:
                 db.session.delete(tag_binding)

api/services/tools/api_tools_manage_service.py

@@ -444,7 +444,7 @@ class ApiToolManageService:
         """
         # get all api providers
         db_providers: list[ApiToolProvider] = (
-            db.session.query(ApiToolProvider).filter(ApiToolProvider.tenant_id == tenant_id).all() or []
+            db.session.query(ApiToolProvider).where(ApiToolProvider.tenant_id == tenant_id).all() or []
         )
 
         result: list[ToolProviderApiEntity] = []

api/services/tools/workflow_tools_manage_service.py

@@ -54,7 +54,7 @@ class WorkflowToolManageService:
         if existing_workflow_tool_provider is not None:
             raise ValueError(f"Tool with name {name} or app_id {workflow_app_id} already exists")
 
-        app: App | None = db.session.query(App).filter(App.id == workflow_app_id, App.tenant_id == tenant_id).first()
+        app: App | None = db.session.query(App).where(App.id == workflow_app_id, App.tenant_id == tenant_id).first()
 
         if app is None:
             raise ValueError(f"App {workflow_app_id} not found")
@@ -144,7 +144,7 @@ class WorkflowToolManageService:
             raise ValueError(f"Tool {workflow_tool_id} not found")
 
         app: App | None = (
-            db.session.query(App).filter(App.id == workflow_tool_provider.app_id, App.tenant_id == tenant_id).first()
+            db.session.query(App).where(App.id == workflow_tool_provider.app_id, App.tenant_id == tenant_id).first()
         )
 
         if app is None:
@@ -186,7 +186,7 @@ class WorkflowToolManageService:
         :param tenant_id: the tenant id
         :return: the list of tools
         """
-        db_tools = db.session.query(WorkflowToolProvider).filter(WorkflowToolProvider.tenant_id == tenant_id).all()
+        db_tools = db.session.query(WorkflowToolProvider).where(WorkflowToolProvider.tenant_id == tenant_id).all()
 
         tools: list[WorkflowToolProviderController] = []
         for provider in db_tools:
@@ -224,7 +224,7 @@ class WorkflowToolManageService:
         :param tenant_id: the tenant id
         :param workflow_tool_id: the workflow tool id
         """
-        db.session.query(WorkflowToolProvider).filter(
+        db.session.query(WorkflowToolProvider).where(
             WorkflowToolProvider.tenant_id == tenant_id, WorkflowToolProvider.id == workflow_tool_id
         ).delete()
 
@@ -275,7 +275,7 @@ class WorkflowToolManageService:
             raise ValueError("Tool not found")
 
         workflow_app: App | None = (
-            db.session.query(App).filter(App.id == db_tool.app_id, App.tenant_id == db_tool.tenant_id).first()
+            db.session.query(App).where(App.id == db_tool.app_id, App.tenant_id == db_tool.tenant_id).first()
         )
 
         if workflow_app is None:

api/services/webapp_auth_service.py

@@ -52,7 +52,7 @@ class WebAppAuthService:
 
     @classmethod
     def get_user_through_email(cls, email: str):
-        account = db.session.query(Account).filter(Account.email == email).first()
+        account = db.session.query(Account).where(Account.email == email).first()
         if not account:
             return None
 
@@ -91,10 +91,10 @@ class WebAppAuthService:
 
     @classmethod
     def create_end_user(cls, app_code, email) -> EndUser:
-        site = db.session.query(Site).filter(Site.code == app_code).first()
+        site = db.session.query(Site).where(Site.code == app_code).first()
         if not site:
             raise NotFound("Site not found.")
-        app_model = db.session.query(App).filter(App.id == site.app_id).first()
+        app_model = db.session.query(App).where(App.id == site.app_id).first()
         if not app_model:
             raise NotFound("App not found.")
         end_user = EndUser(

api/services/workflow_draft_variable_service.py

@@ -138,7 +138,7 @@ class WorkflowDraftVariableService:
         )
 
     def get_variable(self, variable_id: str) -> WorkflowDraftVariable | None:
-        return self._session.query(WorkflowDraftVariable).filter(WorkflowDraftVariable.id == variable_id).first()
+        return self._session.query(WorkflowDraftVariable).where(WorkflowDraftVariable.id == variable_id).first()
 
     def get_draft_variables_by_selectors(
         self,
@@ -166,7 +166,7 @@ class WorkflowDraftVariableService:
     def list_variables_without_values(self, app_id: str, page: int, limit: int) -> WorkflowDraftVariableList:
         criteria = WorkflowDraftVariable.app_id == app_id
         total = None
-        query = self._session.query(WorkflowDraftVariable).filter(criteria)
+        query = self._session.query(WorkflowDraftVariable).where(criteria)
         if page == 1:
             total = query.count()
         variables = (
@@ -185,7 +185,7 @@ class WorkflowDraftVariableService:
             WorkflowDraftVariable.app_id == app_id,
             WorkflowDraftVariable.node_id == node_id,
         )
-        query = self._session.query(WorkflowDraftVariable).filter(*criteria)
+        query = self._session.query(WorkflowDraftVariable).where(*criteria)
         variables = query.order_by(WorkflowDraftVariable.created_at.desc()).all()
         return WorkflowDraftVariableList(variables=variables)
 

api/tasks/add_document_to_index_task.py

@@ -25,7 +25,7 @@ def add_document_to_index_task(dataset_document_id: str):
     logging.info(click.style("Start add document to index: {}".format(dataset_document_id), fg="green"))
     start_at = time.perf_counter()
 
-    dataset_document = db.session.query(DatasetDocument).filter(DatasetDocument.id == dataset_document_id).first()
+    dataset_document = db.session.query(DatasetDocument).where(DatasetDocument.id == dataset_document_id).first()
     if not dataset_document:
         logging.info(click.style("Document not found: {}".format(dataset_document_id), fg="red"))
         db.session.close()
@@ -86,12 +86,12 @@ def add_document_to_index_task(dataset_document_id: str):
         index_processor.load(dataset, documents)
 
         # delete auto disable log
-        db.session.query(DatasetAutoDisableLog).filter(
+        db.session.query(DatasetAutoDisableLog).where(
             DatasetAutoDisableLog.document_id == dataset_document.id
         ).delete()
 
         # update segment to enable
-        db.session.query(DocumentSegment).filter(DocumentSegment.document_id == dataset_document.id).update(
+        db.session.query(DocumentSegment).where(DocumentSegment.document_id == dataset_document.id).update(
             {
                 DocumentSegment.enabled: True,
                 DocumentSegment.disabled_at: None,

api/tasks/annotation/batch_import_annotations_task.py

@@ -29,7 +29,7 @@ def batch_import_annotations_task(job_id: str, content_list: list[dict], app_id:
     start_at = time.perf_counter()
     indexing_cache_key = "app_annotation_batch_import_{}".format(str(job_id))
     # get app info
-    app = db.session.query(App).filter(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
+    app = db.session.query(App).where(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
 
     if app:
         try:
@@ -48,7 +48,7 @@ def batch_import_annotations_task(job_id: str, content_list: list[dict], app_id:
                 documents.append(document)
             # if annotation reply is enabled , batch add annotations' index
             app_annotation_setting = (
-                db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+                db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
             )
 
             if app_annotation_setting:

api/tasks/annotation/disable_annotation_reply_task.py

@@ -19,15 +19,15 @@ def disable_annotation_reply_task(job_id: str, app_id: str, tenant_id: str):
     logging.info(click.style("Start delete app annotations index: {}".format(app_id), fg="green"))
     start_at = time.perf_counter()
     # get app info
-    app = db.session.query(App).filter(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
-    annotations_count = db.session.query(MessageAnnotation).filter(MessageAnnotation.app_id == app_id).count()
+    app = db.session.query(App).where(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
+    annotations_count = db.session.query(MessageAnnotation).where(MessageAnnotation.app_id == app_id).count()
     if not app:
         logging.info(click.style("App not found: {}".format(app_id), fg="red"))
         db.session.close()
         return
 
     app_annotation_setting = (
-        db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+        db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
     )
 
     if not app_annotation_setting:

api/tasks/annotation/enable_annotation_reply_task.py

@@ -30,14 +30,14 @@ def enable_annotation_reply_task(
     logging.info(click.style("Start add app annotation to index: {}".format(app_id), fg="green"))
     start_at = time.perf_counter()
     # get app info
-    app = db.session.query(App).filter(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
+    app = db.session.query(App).where(App.id == app_id, App.tenant_id == tenant_id, App.status == "normal").first()
 
     if not app:
         logging.info(click.style("App not found: {}".format(app_id), fg="red"))
         db.session.close()
         return
 
-    annotations = db.session.query(MessageAnnotation).filter(MessageAnnotation.app_id == app_id).all()
+    annotations = db.session.query(MessageAnnotation).where(MessageAnnotation.app_id == app_id).all()
     enable_app_annotation_key = "enable_app_annotation_{}".format(str(app_id))
     enable_app_annotation_job_key = "enable_app_annotation_job_{}".format(str(job_id))
 
@@ -47,7 +47,7 @@ def enable_annotation_reply_task(
             embedding_provider_name, embedding_model_name, "annotation"
         )
         annotation_setting = (
-            db.session.query(AppAnnotationSetting).filter(AppAnnotationSetting.app_id == app_id).first()
+            db.session.query(AppAnnotationSetting).where(AppAnnotationSetting.app_id == app_id).first()
         )
         if annotation_setting:
             if dataset_collection_binding.id != annotation_setting.collection_binding_id:

api/tasks/batch_clean_document_task.py

@@ -27,12 +27,12 @@ def batch_clean_document_task(document_ids: list[str], dataset_id: str, doc_form
     start_at = time.perf_counter()
 
     try:
-        dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
 
         if not dataset:
             raise Exception("Document has no dataset")
 
-        segments = db.session.query(DocumentSegment).filter(DocumentSegment.document_id.in_(document_ids)).all()
+        segments = db.session.query(DocumentSegment).where(DocumentSegment.document_id.in_(document_ids)).all()
         # check segment is exist
         if segments:
             index_node_ids = [segment.index_node_id for segment in segments]
@@ -42,7 +42,7 @@ def batch_clean_document_task(document_ids: list[str], dataset_id: str, doc_form
             for segment in segments:
                 image_upload_file_ids = get_image_upload_file_ids(segment.content)
                 for upload_file_id in image_upload_file_ids:
-                    image_file = db.session.query(UploadFile).filter(UploadFile.id == upload_file_id).first()
+                    image_file = db.session.query(UploadFile).where(UploadFile.id == upload_file_id).first()
                     try:
                         if image_file and image_file.key:
                             storage.delete(image_file.key)
@@ -56,7 +56,7 @@ def batch_clean_document_task(document_ids: list[str], dataset_id: str, doc_form
 
             db.session.commit()
         if file_ids:
-            files = db.session.query(UploadFile).filter(UploadFile.id.in_(file_ids)).all()
+            files = db.session.query(UploadFile).where(UploadFile.id.in_(file_ids)).all()
             for file in files:
                 try:
                     storage.delete(file.key)

api/tasks/clean_dataset_task.py

@@ -53,8 +53,8 @@ def clean_dataset_task(
             index_struct=index_struct,
             collection_binding_id=collection_binding_id,
         )
-        documents = db.session.query(Document).filter(Document.dataset_id == dataset_id).all()
-        segments = db.session.query(DocumentSegment).filter(DocumentSegment.dataset_id == dataset_id).all()
+        documents = db.session.query(Document).where(Document.dataset_id == dataset_id).all()
+        segments = db.session.query(DocumentSegment).where(DocumentSegment.dataset_id == dataset_id).all()
 
         if documents is None or len(documents) == 0:
             logging.info(click.style("No documents found for dataset: {}".format(dataset_id), fg="green"))
@@ -72,7 +72,7 @@ def clean_dataset_task(
             for segment in segments:
                 image_upload_file_ids = get_image_upload_file_ids(segment.content)
                 for upload_file_id in image_upload_file_ids:
-                    image_file = db.session.query(UploadFile).filter(UploadFile.id == upload_file_id).first()
+                    image_file = db.session.query(UploadFile).where(UploadFile.id == upload_file_id).first()
                     if image_file is None:
                         continue
                     try:
@@ -85,12 +85,12 @@ def clean_dataset_task(
                     db.session.delete(image_file)
                 db.session.delete(segment)
 
-        db.session.query(DatasetProcessRule).filter(DatasetProcessRule.dataset_id == dataset_id).delete()
-        db.session.query(DatasetQuery).filter(DatasetQuery.dataset_id == dataset_id).delete()
-        db.session.query(AppDatasetJoin).filter(AppDatasetJoin.dataset_id == dataset_id).delete()
+        db.session.query(DatasetProcessRule).where(DatasetProcessRule.dataset_id == dataset_id).delete()
+        db.session.query(DatasetQuery).where(DatasetQuery.dataset_id == dataset_id).delete()
+        db.session.query(AppDatasetJoin).where(AppDatasetJoin.dataset_id == dataset_id).delete()
         # delete dataset metadata
-        db.session.query(DatasetMetadata).filter(DatasetMetadata.dataset_id == dataset_id).delete()
-        db.session.query(DatasetMetadataBinding).filter(DatasetMetadataBinding.dataset_id == dataset_id).delete()
+        db.session.query(DatasetMetadata).where(DatasetMetadata.dataset_id == dataset_id).delete()
+        db.session.query(DatasetMetadataBinding).where(DatasetMetadataBinding.dataset_id == dataset_id).delete()
         # delete files
         if documents:
             for document in documents:

api/tasks/clean_document_task.py

@@ -28,12 +28,12 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
     start_at = time.perf_counter()
 
     try:
-        dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
 
         if not dataset:
             raise Exception("Document has no dataset")
 
-        segments = db.session.query(DocumentSegment).filter(DocumentSegment.document_id == document_id).all()
+        segments = db.session.query(DocumentSegment).where(DocumentSegment.document_id == document_id).all()
         # check segment is exist
         if segments:
             index_node_ids = [segment.index_node_id for segment in segments]
@@ -43,7 +43,7 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
             for segment in segments:
                 image_upload_file_ids = get_image_upload_file_ids(segment.content)
                 for upload_file_id in image_upload_file_ids:
-                    image_file = db.session.query(UploadFile).filter(UploadFile.id == upload_file_id).first()
+                    image_file = db.session.query(UploadFile).where(UploadFile.id == upload_file_id).first()
                     if image_file is None:
                         continue
                     try:
@@ -58,7 +58,7 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
 
             db.session.commit()
         if file_id:
-            file = db.session.query(UploadFile).filter(UploadFile.id == file_id).first()
+            file = db.session.query(UploadFile).where(UploadFile.id == file_id).first()
             if file:
                 try:
                     storage.delete(file.key)
@@ -68,7 +68,7 @@ def clean_document_task(document_id: str, dataset_id: str, doc_form: str, file_i
                 db.session.commit()
 
         # delete dataset metadata binding
-        db.session.query(DatasetMetadataBinding).filter(
+        db.session.query(DatasetMetadataBinding).where(
             DatasetMetadataBinding.dataset_id == dataset_id,
             DatasetMetadataBinding.document_id == document_id,
         ).delete()

api/tasks/clean_notion_document_task.py

@@ -24,17 +24,17 @@ def clean_notion_document_task(document_ids: list[str], dataset_id: str):
     start_at = time.perf_counter()
 
     try:
-        dataset = db.session.query(Dataset).filter(Dataset.id == dataset_id).first()
+        dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
 
         if not dataset:
             raise Exception("Document has no dataset")
         index_type = dataset.doc_form
         index_processor = IndexProcessorFactory(index_type).init_index_processor()
         for document_id in document_ids:
-            document = db.session.query(Document).filter(Document.id == document_id).first()
+            document = db.session.query(Document).where(Document.id == document_id).first()
             db.session.delete(document)
 
-            segments = db.session.query(DocumentSegment).filter(DocumentSegment.document_id == document_id).all()
+            segments = db.session.query(DocumentSegment).where(DocumentSegment.document_id == document_id).all()
             index_node_ids = [segment.index_node_id for segment in segments]
 
             index_processor.clean(dataset, index_node_ids, with_keywords=True, delete_child_chunks=True)

api/tasks/create_segment_to_index_task.py

@@ -24,7 +24,7 @@ def create_segment_to_index_task(segment_id: str, keywords: Optional[list[str]]
     logging.info(click.style("Start create segment to index: {}".format(segment_id), fg="green"))
     start_at = time.perf_counter()
 
-    segment = db.session.query(DocumentSegment).filter(DocumentSegment.id == segment_id).first()
+    segment = db.session.query(DocumentSegment).where(DocumentSegment.id == segment_id).first()
     if not segment:
         logging.info(click.style("Segment not found: {}".format(segment_id), fg="red"))
         db.session.close()

api/tasks/deal_dataset_vector_index_task.py

@@ -46,7 +46,7 @@ def deal_dataset_vector_index_task(dataset_id: str, action: str):
 
             if dataset_documents:
                 dataset_documents_ids = [doc.id for doc in dataset_documents]
-                db.session.query(DatasetDocument).filter(DatasetDocument.id.in_(dataset_documents_ids)).update(
+                db.session.query(DatasetDocument).where(DatasetDocument.id.in_(dataset_documents_ids)).update(
                     {"indexing_status": "indexing"}, synchronize_session=False
                 )
                 db.session.commit()
@@ -76,12 +76,12 @@ def deal_dataset_vector_index_task(dataset_id: str, action: str):
                                 documents.append(document)
                             # save vector index
                             index_processor.load(dataset, documents, with_keywords=False)
-                        db.session.query(DatasetDocument).filter(DatasetDocument.id == dataset_document.id).update(
+                        db.session.query(DatasetDocument).where(DatasetDocument.id == dataset_document.id).update(
                             {"indexing_status": "completed"}, synchronize_session=False
                         )
                         db.session.commit()
                     except Exception as e:
-                        db.session.query(DatasetDocument).filter(DatasetDocument.id == dataset_document.id).update(
+                        db.session.query(DatasetDocument).where(DatasetDocument.id == dataset_document.id).update(
                             {"indexing_status": "error", "error": str(e)}, synchronize_session=False
                         )
                         db.session.commit()
@@ -100,7 +100,7 @@ def deal_dataset_vector_index_task(dataset_id: str, action: str):
             if dataset_documents:
                 # update document status
                 dataset_documents_ids = [doc.id for doc in dataset_documents]
-                db.session.query(DatasetDocument).filter(DatasetDocument.id.in_(dataset_documents_ids)).update(
+                db.session.query(DatasetDocument).where(DatasetDocument.id.in_(dataset_documents_ids)).update(
                     {"indexing_status": "indexing"}, synchronize_session=False
                 )
                 db.session.commit()
@@ -148,12 +148,12 @@ def deal_dataset_vector_index_task(dataset_id: str, action: str):
                                 documents.append(document)
                             # save vector index
                             index_processor.load(dataset, documents, with_keywords=False)
-                        db.session.query(DatasetDocument).filter(DatasetDocument.id == dataset_document.id).update(
+                        db.session.query(DatasetDocument).where(DatasetDocument.id == dataset_document.id).update(
                             {"indexing_status": "completed"}, synchronize_session=False
                         )
                         db.session.commit()
                     except Exception as e:
-                        db.session.query(DatasetDocument).filter(DatasetDocument.id == dataset_document.id).update(
+                        db.session.query(DatasetDocument).where(DatasetDocument.id == dataset_document.id).update(
                             {"indexing_status": "error", "error": str(e)}, synchronize_session=False
                         )
                         db.session.commit()