refine some orm types (#22885)

api/models/account.py

 from typing import Optional, cast
 
 from flask_login import UserMixin  # type: ignore
-from sqlalchemy import func, select
+from sqlalchemy import DateTime, String, func, select
 from sqlalchemy.orm import Mapped, mapped_column, reconstructor
 
 from models.base import Base
     __table_args__ = (db.PrimaryKeyConstraint("id", name="account_pkey"), db.Index("account_email_idx", "email"))
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
-    name: Mapped[str] = mapped_column(db.String(255))
-    email: Mapped[str] = mapped_column(db.String(255))
-    password: Mapped[Optional[str]] = mapped_column(db.String(255))
-    password_salt: Mapped[Optional[str]] = mapped_column(db.String(255))
-    avatar: Mapped[Optional[str]] = mapped_column(db.String(255), nullable=True)
-    interface_language: Mapped[Optional[str]] = mapped_column(db.String(255))
-    interface_theme: Mapped[Optional[str]] = mapped_column(db.String(255), nullable=True)
-    timezone: Mapped[Optional[str]] = mapped_column(db.String(255))
-    last_login_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime, nullable=True)
-    last_login_ip: Mapped[Optional[str]] = mapped_column(db.String(255), nullable=True)
-    last_active_at: Mapped[datetime] = mapped_column(
-        db.DateTime, server_default=func.current_timestamp(), nullable=False
-    )
-    status: Mapped[str] = mapped_column(db.String(16), server_default=db.text("'active'::character varying"))
-    initialized_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime, nullable=True)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp(), nullable=False)
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp(), nullable=False)
+    name: Mapped[str] = mapped_column(String(255))
+    email: Mapped[str] = mapped_column(String(255))
+    password: Mapped[Optional[str]] = mapped_column(String(255))
+    password_salt: Mapped[Optional[str]] = mapped_column(String(255))
+    avatar: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    interface_language: Mapped[Optional[str]] = mapped_column(String(255))
+    interface_theme: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    timezone: Mapped[Optional[str]] = mapped_column(String(255))
+    last_login_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    last_login_ip: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    last_active_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    status: Mapped[str] = mapped_column(String(16), server_default=db.text("'active'::character varying"))
+    initialized_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
 
     @reconstructor
     def init_on_load(self):
     __table_args__ = (db.PrimaryKeyConstraint("id", name="tenant_pkey"),)
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
-    name: Mapped[str] = mapped_column(db.String(255))
+    name: Mapped[str] = mapped_column(String(255))
     encrypt_public_key = db.Column(db.Text)
-    plan: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'basic'::character varying"))
-    status: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'normal'::character varying"))
+    plan: Mapped[str] = mapped_column(String(255), server_default=db.text("'basic'::character varying"))
+    status: Mapped[str] = mapped_column(String(255), server_default=db.text("'normal'::character varying"))
     custom_config: Mapped[Optional[str]] = mapped_column(db.Text)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp(), nullable=False)
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp(), nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
 
     def get_accounts(self) -> list[Account]:
         return (
     tenant_id: Mapped[str] = mapped_column(StringUUID)
     account_id: Mapped[str] = mapped_column(StringUUID)
     current: Mapped[bool] = mapped_column(db.Boolean, server_default=db.text("false"))
-    role: Mapped[str] = mapped_column(db.String(16), server_default="normal")
+    role: Mapped[str] = mapped_column(String(16), server_default="normal")
     invited_by: Mapped[Optional[str]] = mapped_column(StringUUID)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
 
 
 class AccountIntegrate(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     account_id: Mapped[str] = mapped_column(StringUUID)
-    provider: Mapped[str] = mapped_column(db.String(16))
-    open_id: Mapped[str] = mapped_column(db.String(255))
-    encrypted_token: Mapped[str] = mapped_column(db.String(255))
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
+    provider: Mapped[str] = mapped_column(String(16))
+    open_id: Mapped[str] = mapped_column(String(255))
+    encrypted_token: Mapped[str] = mapped_column(String(255))
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
 
 
 class InvitationCode(Base):
     )
 
     id: Mapped[int] = mapped_column(db.Integer)
-    batch: Mapped[str] = mapped_column(db.String(255))
-    code: Mapped[str] = mapped_column(db.String(32))
-    status: Mapped[str] = mapped_column(db.String(16), server_default=db.text("'unused'::character varying"))
-    used_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
+    batch: Mapped[str] = mapped_column(String(255))
+    code: Mapped[str] = mapped_column(String(32))
+    status: Mapped[str] = mapped_column(String(16), server_default=db.text("'unused'::character varying"))
+    used_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
     used_by_tenant_id: Mapped[Optional[str]] = mapped_column(StringUUID)
     used_by_account_id: Mapped[Optional[str]] = mapped_column(StringUUID)
-    deprecated_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime, nullable=True)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    deprecated_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=db.text("CURRENT_TIMESTAMP(0)"))
 
 
 class TenantPluginPermission(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    install_permission: Mapped[InstallPermission] = mapped_column(
-        db.String(16), nullable=False, server_default="everyone"
-    )
-    debug_permission: Mapped[DebugPermission] = mapped_column(db.String(16), nullable=False, server_default="noone")
+    install_permission: Mapped[InstallPermission] = mapped_column(String(16), nullable=False, server_default="everyone")
+    debug_permission: Mapped[DebugPermission] = mapped_column(String(16), nullable=False, server_default="noone")
 
 
 class TenantPluginAutoUpgradeStrategy(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    strategy_setting: Mapped[StrategySetting] = mapped_column(db.String(16), nullable=False, server_default="fix_only")
+    strategy_setting: Mapped[StrategySetting] = mapped_column(String(16), nullable=False, server_default="fix_only")
     upgrade_time_of_day: Mapped[int] = mapped_column(db.Integer, nullable=False, default=0)  # seconds of the day
-    upgrade_mode: Mapped[UpgradeMode] = mapped_column(db.String(16), nullable=False, server_default="exclude")
-    exclude_plugins: Mapped[list[str]] = mapped_column(
-        db.ARRAY(db.String(255)), nullable=False
-    )  # plugin_id (author/name)
-    include_plugins: Mapped[list[str]] = mapped_column(
-        db.ARRAY(db.String(255)), nullable=False
-    )  # plugin_id (author/name)
-    created_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at = db.Column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    upgrade_mode: Mapped[UpgradeMode] = mapped_column(String(16), nullable=False, server_default="exclude")
+    exclude_plugins: Mapped[list[str]] = mapped_column(db.ARRAY(String(255)), nullable=False)  # plugin_id (author/name)
+    include_plugins: Mapped[list[str]] = mapped_column(db.ARRAY(String(255)), nullable=False)  # plugin_id (author/name)
+    created_at = db.Column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = db.Column(DateTime, nullable=False, server_default=func.current_timestamp())

api/models/api_based_extension.py

 import enum
+from datetime import datetime
 
-from sqlalchemy import func
-from sqlalchemy.orm import mapped_column
+from sqlalchemy import DateTime, String, Text, func
+from sqlalchemy.orm import Mapped, mapped_column
 
 from .base import Base
 from .engine import db
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
-    name = mapped_column(db.String(255), nullable=False)
-    api_endpoint = mapped_column(db.String(255), nullable=False)
-    api_key = mapped_column(db.Text, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    api_endpoint: Mapped[str] = mapped_column(String(255), nullable=False)
+    api_key = mapped_column(Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

api/models/dataset.py

 from json import JSONDecodeError
 from typing import Any, Optional, cast
 
-from sqlalchemy import func, select
+from sqlalchemy import DateTime, String, func, select
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm import Mapped, mapped_column
 
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID)
-    name: Mapped[str] = mapped_column(db.String(255))
+    name: Mapped[str] = mapped_column(String(255))
     description = mapped_column(db.Text, nullable=True)
-    provider: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'vendor'::character varying"))
-    permission: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'only_me'::character varying"))
-    data_source_type = mapped_column(db.String(255))
-    indexing_technique: Mapped[Optional[str]] = mapped_column(db.String(255))
+    provider: Mapped[str] = mapped_column(String(255), server_default=db.text("'vendor'::character varying"))
+    permission: Mapped[str] = mapped_column(String(255), server_default=db.text("'only_me'::character varying"))
+    data_source_type = mapped_column(String(255))
+    indexing_technique: Mapped[Optional[str]] = mapped_column(String(255))
     index_struct = mapped_column(db.Text, nullable=True)
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by = mapped_column(StringUUID, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    embedding_model = db.Column(db.String(255), nullable=True)  # TODO: mapped_column
-    embedding_model_provider = db.Column(db.String(255), nullable=True)  # TODO: mapped_column
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    embedding_model = db.Column(String(255), nullable=True)  # TODO: mapped_column
+    embedding_model_provider = db.Column(String(255), nullable=True)  # TODO: mapped_column
     collection_binding_id = mapped_column(StringUUID, nullable=True)
     retrieval_model = mapped_column(JSONB, nullable=True)
-    built_in_field_enabled = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    built_in_field_enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
 
     @property
     def dataset_keyword_table(self):
 
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     dataset_id = mapped_column(StringUUID, nullable=False)
-    mode = mapped_column(db.String(255), nullable=False, server_default=db.text("'automatic'::character varying"))
+    mode = mapped_column(String(255), nullable=False, server_default=db.text("'automatic'::character varying"))
     rules = mapped_column(db.Text, nullable=True)
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     MODES = ["automatic", "custom", "hierarchical"]
     PRE_PROCESSING_RULES = ["remove_stopwords", "remove_extra_spaces", "remove_urls_emails"]
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
     dataset_id = mapped_column(StringUUID, nullable=False)
-    position = mapped_column(db.Integer, nullable=False)
-    data_source_type = mapped_column(db.String(255), nullable=False)
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False)
+    data_source_type: Mapped[str] = mapped_column(String(255), nullable=False)
     data_source_info = mapped_column(db.Text, nullable=True)
     dataset_process_rule_id = mapped_column(StringUUID, nullable=True)
-    batch = mapped_column(db.String(255), nullable=False)
-    name = mapped_column(db.String(255), nullable=False)
-    created_from = mapped_column(db.String(255), nullable=False)
+    batch: Mapped[str] = mapped_column(String(255), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_from: Mapped[str] = mapped_column(String(255), nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
     created_api_request_id = mapped_column(StringUUID, nullable=True)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     # start processing
-    processing_started_at = mapped_column(db.DateTime, nullable=True)
+    processing_started_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # parsing
     file_id = mapped_column(db.Text, nullable=True)
-    word_count = mapped_column(db.Integer, nullable=True)
-    parsing_completed_at = mapped_column(db.DateTime, nullable=True)
+    word_count: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)  # TODO: make this not nullable
+    parsing_completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # cleaning
-    cleaning_completed_at = mapped_column(db.DateTime, nullable=True)
+    cleaning_completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # split
-    splitting_completed_at = mapped_column(db.DateTime, nullable=True)
+    splitting_completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # indexing
-    tokens = mapped_column(db.Integer, nullable=True)
-    indexing_latency = mapped_column(db.Float, nullable=True)
-    completed_at = mapped_column(db.DateTime, nullable=True)
+    tokens: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
+    indexing_latency: Mapped[Optional[float]] = mapped_column(db.Float, nullable=True)
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # pause
-    is_paused = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
+    is_paused: Mapped[Optional[bool]] = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
     paused_by = mapped_column(StringUUID, nullable=True)
-    paused_at = mapped_column(db.DateTime, nullable=True)
+    paused_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # error
     error = mapped_column(db.Text, nullable=True)
-    stopped_at = mapped_column(db.DateTime, nullable=True)
+    stopped_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     # basic fields
-    indexing_status = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'waiting'::character varying")
-    )
-    enabled = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
-    disabled_at = mapped_column(db.DateTime, nullable=True)
+    indexing_status = mapped_column(String(255), nullable=False, server_default=db.text("'waiting'::character varying"))
+    enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    disabled_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
     disabled_by = mapped_column(StringUUID, nullable=True)
-    archived = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
-    archived_reason = mapped_column(db.String(255), nullable=True)
+    archived: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    archived_reason = mapped_column(String(255), nullable=True)
     archived_by = mapped_column(StringUUID, nullable=True)
-    archived_at = mapped_column(db.DateTime, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    doc_type = mapped_column(db.String(40), nullable=True)
+    archived_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    doc_type = mapped_column(String(40), nullable=True)
     doc_metadata = mapped_column(JSONB, nullable=True)
-    doc_form = mapped_column(db.String(255), nullable=False, server_default=db.text("'text_model'::character varying"))
-    doc_language = mapped_column(db.String(255), nullable=True)
+    doc_form = mapped_column(String(255), nullable=False, server_default=db.text("'text_model'::character varying"))
+    doc_language = mapped_column(String(255), nullable=True)
 
     DATA_SOURCES = ["upload_file", "notion_import", "website_crawl"]
 
                 "id": "built-in",
                 "name": BuiltInField.upload_date,
                 "type": "time",
-                "value": self.created_at.timestamp(),
+                "value": str(self.created_at.timestamp()),
             }
         )
         built_in_fields.append(
                 "id": "built-in",
                 "name": BuiltInField.last_update_date,
                 "type": "time",
-                "value": self.updated_at.timestamp(),
+                "value": str(self.updated_at.timestamp()),
             }
         )
         built_in_fields.append(
 
     # indexing fields
     keywords = mapped_column(db.JSON, nullable=True)
-    index_node_id = mapped_column(db.String(255), nullable=True)
-    index_node_hash = mapped_column(db.String(255), nullable=True)
+    index_node_id = mapped_column(String(255), nullable=True)
+    index_node_hash = mapped_column(String(255), nullable=True)
 
     # basic fields
-    hit_count = mapped_column(db.Integer, nullable=False, default=0)
-    enabled = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
-    disabled_at = mapped_column(db.DateTime, nullable=True)
+    hit_count: Mapped[int] = mapped_column(db.Integer, nullable=False, default=0)
+    enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    disabled_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
     disabled_by = mapped_column(StringUUID, nullable=True)
-    status: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'waiting'::character varying"))
+    status: Mapped[str] = mapped_column(String(255), server_default=db.text("'waiting'::character varying"))
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by = mapped_column(StringUUID, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    indexing_at = mapped_column(db.DateTime, nullable=True)
-    completed_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime, nullable=True)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    indexing_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
     error = mapped_column(db.Text, nullable=True)
-    stopped_at = mapped_column(db.DateTime, nullable=True)
+    stopped_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     @property
     def dataset(self):
     dataset_id = mapped_column(StringUUID, nullable=False)
     document_id = mapped_column(StringUUID, nullable=False)
     segment_id = mapped_column(StringUUID, nullable=False)
-    position = mapped_column(db.Integer, nullable=False)
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False)
     content = mapped_column(db.Text, nullable=False)
-    word_count = mapped_column(db.Integer, nullable=False)
+    word_count: Mapped[int] = mapped_column(db.Integer, nullable=False)
     # indexing fields
-    index_node_id = mapped_column(db.String(255), nullable=True)
-    index_node_hash = mapped_column(db.String(255), nullable=True)
-    type = mapped_column(db.String(255), nullable=False, server_default=db.text("'automatic'::character varying"))
+    index_node_id = mapped_column(String(255), nullable=True)
+    index_node_hash = mapped_column(String(255), nullable=True)
+    type = mapped_column(String(255), nullable=False, server_default=db.text("'automatic'::character varying"))
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
     updated_by = mapped_column(StringUUID, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
-    indexing_at = mapped_column(db.DateTime, nullable=True)
-    completed_at = mapped_column(db.DateTime, nullable=True)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+    indexing_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    completed_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
     error = mapped_column(db.Text, nullable=True)
 
     @property
     id = mapped_column(StringUUID, primary_key=True, nullable=False, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
     dataset_id = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=db.func.current_timestamp())
 
     @property
     def app(self):
     id = mapped_column(StringUUID, primary_key=True, nullable=False, server_default=db.text("uuid_generate_v4()"))
     dataset_id = mapped_column(StringUUID, nullable=False)
     content = mapped_column(db.Text, nullable=False)
-    source = mapped_column(db.String(255), nullable=False)
+    source: Mapped[str] = mapped_column(String(255), nullable=False)
     source_app_id = mapped_column(StringUUID, nullable=True)
-    created_by_role = mapped_column(db.String, nullable=False)
+    created_by_role = mapped_column(String, nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=db.func.current_timestamp())
 
 
 class DatasetKeywordTable(Base):
     dataset_id = mapped_column(StringUUID, nullable=False, unique=True)
     keyword_table = mapped_column(db.Text, nullable=False)
     data_source_type = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'database'::character varying")
+        String(255), nullable=False, server_default=db.text("'database'::character varying")
     )
 
     @property
 
     id = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
     model_name = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'text-embedding-ada-002'::character varying")
+        String(255), nullable=False, server_default=db.text("'text-embedding-ada-002'::character varying")
     )
-    hash = mapped_column(db.String(64), nullable=False)
+    hash = mapped_column(String(64), nullable=False)
     embedding = mapped_column(db.LargeBinary, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    provider_name = mapped_column(db.String(255), nullable=False, server_default=db.text("''::character varying"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    provider_name = mapped_column(String(255), nullable=False, server_default=db.text("''::character varying"))
 
     def set_embedding(self, embedding_data: list[float]):
         self.embedding = pickle.dumps(embedding_data, protocol=pickle.HIGHEST_PROTOCOL)
     )
 
     id = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
-    provider_name = mapped_column(db.String(255), nullable=False)
-    model_name = mapped_column(db.String(255), nullable=False)
-    type = mapped_column(db.String(40), server_default=db.text("'dataset'::character varying"), nullable=False)
-    collection_name = mapped_column(db.String(64), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    type = mapped_column(String(40), server_default=db.text("'dataset'::character varying"), nullable=False)
+    collection_name = mapped_column(String(64), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class TidbAuthBinding(Base):
     )
     id = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=True)
-    cluster_id = mapped_column(db.String(255), nullable=False)
-    cluster_name = mapped_column(db.String(255), nullable=False)
-    active = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
-    status = mapped_column(db.String(255), nullable=False, server_default=db.text("CREATING"))
-    account = mapped_column(db.String(255), nullable=False)
-    password = mapped_column(db.String(255), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    cluster_id: Mapped[str] = mapped_column(String(255), nullable=False)
+    cluster_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    active: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    status = mapped_column(String(255), nullable=False, server_default=db.text("CREATING"))
+    account: Mapped[str] = mapped_column(String(255), nullable=False)
+    password: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class Whitelist(Base):
     )
     id = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=True)
-    category = mapped_column(db.String(255), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    category: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class DatasetPermission(Base):
     dataset_id = mapped_column(StringUUID, nullable=False)
     account_id = mapped_column(StringUUID, nullable=False)
     tenant_id = mapped_column(StringUUID, nullable=False)
-    has_permission = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    has_permission: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class ExternalKnowledgeApis(Base):
     )
 
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
-    name = mapped_column(db.String(255), nullable=False)
-    description = mapped_column(db.String(255), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str] = mapped_column(String(255), nullable=False)
     tenant_id = mapped_column(StringUUID, nullable=False)
     settings = mapped_column(db.Text, nullable=True)
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by = mapped_column(StringUUID, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     def to_dict(self):
         return {
     dataset_id = mapped_column(StringUUID, nullable=False)
     external_knowledge_id = mapped_column(db.Text, nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by = mapped_column(StringUUID, nullable=True)
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class DatasetAutoDisableLog(Base):
     tenant_id = mapped_column(StringUUID, nullable=False)
     dataset_id = mapped_column(StringUUID, nullable=False)
     document_id = mapped_column(StringUUID, nullable=False)
-    notified = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    notified: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
 
 
 class RateLimitLog(Base):
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
-    subscription_plan = mapped_column(db.String(255), nullable=False)
-    operation = mapped_column(db.String(255), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    subscription_plan: Mapped[str] = mapped_column(String(255), nullable=False)
+    operation: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
 
 
 class DatasetMetadata(Base):
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
     dataset_id = mapped_column(StringUUID, nullable=False)
-    type = mapped_column(db.String(255), nullable=False)
-    name = mapped_column(db.String(255), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    type: Mapped[str] = mapped_column(String(255), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+    )
     created_by = mapped_column(StringUUID, nullable=False)
     updated_by = mapped_column(StringUUID, nullable=True)
 
     dataset_id = mapped_column(StringUUID, nullable=False)
     metadata_id = mapped_column(StringUUID, nullable=False)
     document_id = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     created_by = mapped_column(StringUUID, nullable=False)

api/models/model.py

 import sqlalchemy as sa
 from flask import request
 from flask_login import UserMixin
-from sqlalchemy import Float, Index, PrimaryKeyConstraint, func, text
+from sqlalchemy import Float, Index, PrimaryKeyConstraint, String, func, text
 from sqlalchemy.orm import Mapped, Session, mapped_column
 
 from configs import dify_config
     __tablename__ = "dify_setups"
     __table_args__ = (db.PrimaryKeyConstraint("version", name="dify_setup_pkey"),)
 
-    version = mapped_column(db.String(255), nullable=False)
+    version: Mapped[str] = mapped_column(String(255), nullable=False)
     setup_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID)
-    name: Mapped[str] = mapped_column(db.String(255))
+    name: Mapped[str] = mapped_column(String(255))
     description: Mapped[str] = mapped_column(db.Text, server_default=db.text("''::character varying"))
-    mode: Mapped[str] = mapped_column(db.String(255))
-    icon_type: Mapped[Optional[str]] = mapped_column(db.String(255))  # image, emoji
-    icon = db.Column(db.String(255))
-    icon_background: Mapped[Optional[str]] = mapped_column(db.String(255))
+    mode: Mapped[str] = mapped_column(String(255))
+    icon_type: Mapped[Optional[str]] = mapped_column(String(255))  # image, emoji
+    icon = db.Column(String(255))
+    icon_background: Mapped[Optional[str]] = mapped_column(String(255))
     app_model_config_id = mapped_column(StringUUID, nullable=True)
     workflow_id = mapped_column(StringUUID, nullable=True)
-    status: Mapped[str] = mapped_column(db.String(255), server_default=db.text("'normal'::character varying"))
+    status: Mapped[str] = mapped_column(String(255), server_default=db.text("'normal'::character varying"))
     enable_site: Mapped[bool] = mapped_column(db.Boolean)
     enable_api: Mapped[bool] = mapped_column(db.Boolean)
     api_rpm: Mapped[int] = mapped_column(db.Integer, server_default=db.text("0"))
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
-    provider = mapped_column(db.String(255), nullable=True)
-    model_id = mapped_column(db.String(255), nullable=True)
+    provider = mapped_column(String(255), nullable=True)
+    model_id = mapped_column(String(255), nullable=True)
     configs = mapped_column(db.JSON, nullable=True)
     created_by = mapped_column(StringUUID, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     more_like_this = mapped_column(db.Text)
     model = mapped_column(db.Text)
     user_input_form = mapped_column(db.Text)
-    dataset_query_variable = mapped_column(db.String(255))
+    dataset_query_variable = mapped_column(String(255))
     pre_prompt = mapped_column(db.Text)
     agent_mode = mapped_column(db.Text)
     sensitive_word_avoidance = mapped_column(db.Text)
     retriever_resource = mapped_column(db.Text)
-    prompt_type = mapped_column(db.String(255), nullable=False, server_default=db.text("'simple'::character varying"))
+    prompt_type = mapped_column(String(255), nullable=False, server_default=db.text("'simple'::character varying"))
     chat_prompt_config = mapped_column(db.Text)
     completion_prompt_config = mapped_column(db.Text)
     dataset_configs = mapped_column(db.Text)
     id = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
     description = mapped_column(db.JSON, nullable=False)
-    copyright = mapped_column(db.String(255), nullable=False)
-    privacy_policy = mapped_column(db.String(255), nullable=False)
+    copyright: Mapped[str] = mapped_column(String(255), nullable=False)
+    privacy_policy: Mapped[str] = mapped_column(String(255), nullable=False)
     custom_disclaimer: Mapped[str] = mapped_column(sa.TEXT, default="")
-    category = mapped_column(db.String(255), nullable=False)
-    position = mapped_column(db.Integer, nullable=False, default=0)
-    is_listed = mapped_column(db.Boolean, nullable=False, default=True)
-    install_count = mapped_column(db.Integer, nullable=False, default=0)
-    language = mapped_column(db.String(255), nullable=False, server_default=db.text("'en-US'::character varying"))
+    category: Mapped[str] = mapped_column(String(255), nullable=False)
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False, default=0)
+    is_listed: Mapped[bool] = mapped_column(db.Boolean, nullable=False, default=True)
+    install_count: Mapped[int] = mapped_column(db.Integer, nullable=False, default=0)
+    language = mapped_column(String(255), nullable=False, server_default=db.text("'en-US'::character varying"))
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
     tenant_id = mapped_column(StringUUID, nullable=False)
     app_id = mapped_column(StringUUID, nullable=False)
     app_owner_tenant_id = mapped_column(StringUUID, nullable=False)
-    position = mapped_column(db.Integer, nullable=False, default=0)
-    is_pinned = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False, default=0)
+    is_pinned: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
     last_used_at = mapped_column(db.DateTime, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
     app_model_config_id = mapped_column(StringUUID, nullable=True)
-    model_provider = mapped_column(db.String(255), nullable=True)
+    model_provider = mapped_column(String(255), nullable=True)
     override_model_configs = mapped_column(db.Text)
-    model_id = mapped_column(db.String(255), nullable=True)
-    mode: Mapped[str] = mapped_column(db.String(255))
-    name = mapped_column(db.String(255), nullable=False)
+    model_id = mapped_column(String(255), nullable=True)
+    mode: Mapped[str] = mapped_column(String(255))
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
     summary = mapped_column(db.Text)
     _inputs: Mapped[dict] = mapped_column("inputs", db.JSON)
     introduction = mapped_column(db.Text)
     system_instruction = mapped_column(db.Text)
-    system_instruction_tokens = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
-    status = mapped_column(db.String(255), nullable=False)
+    system_instruction_tokens: Mapped[int] = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
+    status: Mapped[str] = mapped_column(String(255), nullable=False)
 
     # The `invoke_from` records how the conversation is created.
     #
     # Its value corresponds to the members of `InvokeFrom`.
     # (api/core/app/entities/app_invoke_entities.py)
-    invoke_from = mapped_column(db.String(255), nullable=True)
+    invoke_from = mapped_column(String(255), nullable=True)
 
     # ref: ConversationSource.
-    from_source = mapped_column(db.String(255), nullable=False)
+    from_source: Mapped[str] = mapped_column(String(255), nullable=False)
     from_end_user_id = mapped_column(StringUUID)
     from_account_id = mapped_column(StringUUID)
     read_at = mapped_column(db.DateTime)
         "MessageAnnotation", backref="conversation", lazy="select", passive_deletes="all"
     )
 
-    is_deleted = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    is_deleted: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
 
     @property
     def inputs(self):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
-    model_provider = mapped_column(db.String(255), nullable=True)
-    model_id = mapped_column(db.String(255), nullable=True)
+    model_provider = mapped_column(String(255), nullable=True)
+    model_id = mapped_column(String(255), nullable=True)
     override_model_configs = mapped_column(db.Text)
     conversation_id = mapped_column(StringUUID, db.ForeignKey("conversations.id"), nullable=False)
     _inputs: Mapped[dict] = mapped_column("inputs", db.JSON)
     parent_message_id = mapped_column(StringUUID, nullable=True)
     provider_response_latency = mapped_column(db.Float, nullable=False, server_default=db.text("0"))
     total_price = mapped_column(db.Numeric(10, 7))
-    currency = mapped_column(db.String(255), nullable=False)
-    status = mapped_column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
+    currency: Mapped[str] = mapped_column(String(255), nullable=False)
+    status = mapped_column(String(255), nullable=False, server_default=db.text("'normal'::character varying"))
     error = mapped_column(db.Text)
     message_metadata = mapped_column(db.Text)
-    invoke_from: Mapped[Optional[str]] = mapped_column(db.String(255), nullable=True)
-    from_source = mapped_column(db.String(255), nullable=False)
+    invoke_from: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
+    from_source: Mapped[str] = mapped_column(String(255), nullable=False)
     from_end_user_id: Mapped[Optional[str]] = mapped_column(StringUUID)
     from_account_id: Mapped[Optional[str]] = mapped_column(StringUUID)
     created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    agent_based = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    agent_based: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
     workflow_run_id: Mapped[Optional[str]] = mapped_column(StringUUID)
 
     @property
     app_id = mapped_column(StringUUID, nullable=False)
     conversation_id = mapped_column(StringUUID, nullable=False)
     message_id = mapped_column(StringUUID, nullable=False)
-    rating = mapped_column(db.String(255), nullable=False)
+    rating: Mapped[str] = mapped_column(String(255), nullable=False)
     content = mapped_column(db.Text)
-    from_source = mapped_column(db.String(255), nullable=False)
+    from_source: Mapped[str] = mapped_column(String(255), nullable=False)
     from_end_user_id = mapped_column(StringUUID)
     from_account_id = mapped_column(StringUUID)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     message_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    type: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    transfer_method: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    type: Mapped[str] = mapped_column(String(255), nullable=False)
+    transfer_method: Mapped[str] = mapped_column(String(255), nullable=False)
     url: Mapped[Optional[str]] = mapped_column(db.Text, nullable=True)
-    belongs_to: Mapped[Optional[str]] = mapped_column(db.String(255), nullable=True)
+    belongs_to: Mapped[Optional[str]] = mapped_column(String(255), nullable=True)
     upload_file_id: Mapped[Optional[str]] = mapped_column(StringUUID, nullable=True)
-    created_by_role: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    created_by_role: Mapped[str] = mapped_column(String(255), nullable=False)
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
     created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
     message_id: Mapped[Optional[str]] = mapped_column(StringUUID)
     question = db.Column(db.Text, nullable=True)
     content = mapped_column(db.Text, nullable=False)
-    hit_count = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
+    hit_count: Mapped[int] = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
     account_id = mapped_column(StringUUID, nullable=False)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
     account_id = mapped_column(StringUUID, nullable=False)
-    action = mapped_column(db.String(255), nullable=False)
+    action: Mapped[str] = mapped_column(String(255), nullable=False)
     content = mapped_column(db.JSON)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    created_ip = mapped_column(db.String(255), nullable=False)
+    created_ip: Mapped[str] = mapped_column(String(255), nullable=False)
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     app_id = mapped_column(StringUUID, nullable=True)
-    type = mapped_column(db.String(255), nullable=False)
-    external_user_id = mapped_column(db.String(255), nullable=True)
-    name = mapped_column(db.String(255))
-    is_anonymous = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    type: Mapped[str] = mapped_column(String(255), nullable=False)
+    external_user_id = mapped_column(String(255), nullable=True)
+    name = mapped_column(String(255))
+    is_anonymous: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
     session_id: Mapped[str] = mapped_column()
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
     app_id = mapped_column(StringUUID, nullable=False)
-    name = mapped_column(db.String(255), nullable=False)
-    description = mapped_column(db.String(255), nullable=False)
-    server_code = mapped_column(db.String(255), nullable=False)
-    status = mapped_column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str] = mapped_column(String(255), nullable=False)
+    server_code: Mapped[str] = mapped_column(String(255), nullable=False)
+    status = mapped_column(String(255), nullable=False, server_default=db.text("'normal'::character varying"))
     parameters = mapped_column(db.Text, nullable=False)
 
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
-    title = mapped_column(db.String(255), nullable=False)
-    icon_type = mapped_column(db.String(255), nullable=True)
-    icon = mapped_column(db.String(255))
-    icon_background = mapped_column(db.String(255))
+    title: Mapped[str] = mapped_column(String(255), nullable=False)
+    icon_type = mapped_column(String(255), nullable=True)
+    icon = mapped_column(String(255))
+    icon_background = mapped_column(String(255))
     description = mapped_column(db.Text)
-    default_language = mapped_column(db.String(255), nullable=False)
-    chat_color_theme = mapped_column(db.String(255))
-    chat_color_theme_inverted = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
-    copyright = mapped_column(db.String(255))
-    privacy_policy = mapped_column(db.String(255))
-    show_workflow_steps = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
-    use_icon_as_answer_icon = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    default_language: Mapped[str] = mapped_column(String(255), nullable=False)
+    chat_color_theme = mapped_column(String(255))
+    chat_color_theme_inverted: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    copyright = mapped_column(String(255))
+    privacy_policy = mapped_column(String(255))
+    show_workflow_steps: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    use_icon_as_answer_icon: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
     _custom_disclaimer: Mapped[str] = mapped_column("custom_disclaimer", sa.TEXT, default="")
-    customize_domain = mapped_column(db.String(255))
-    customize_token_strategy = mapped_column(db.String(255), nullable=False)
-    prompt_public = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
-    status = mapped_column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
+    customize_domain = mapped_column(String(255))
+    customize_token_strategy: Mapped[str] = mapped_column(String(255), nullable=False)
+    prompt_public: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
+    status = mapped_column(String(255), nullable=False, server_default=db.text("'normal'::character varying"))
     created_by = mapped_column(StringUUID, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by = mapped_column(StringUUID, nullable=True)
     updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    code = mapped_column(db.String(255))
+    code = mapped_column(String(255))
 
     @property
     def custom_disclaimer(self):
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=True)
     tenant_id = mapped_column(StringUUID, nullable=True)
-    type = mapped_column(db.String(16), nullable=False)
-    token = mapped_column(db.String(255), nullable=False)
+    type = mapped_column(String(16), nullable=False)
+    token: Mapped[str] = mapped_column(String(255), nullable=False)
     last_used_at = mapped_column(db.DateTime, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    storage_type: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    key: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    storage_type: Mapped[str] = mapped_column(String(255), nullable=False)
+    key: Mapped[str] = mapped_column(String(255), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
     size: Mapped[int] = mapped_column(db.Integer, nullable=False)
-    extension: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    mime_type: Mapped[str] = mapped_column(db.String(255), nullable=True)
+    extension: Mapped[str] = mapped_column(String(255), nullable=False)
+    mime_type: Mapped[str] = mapped_column(String(255), nullable=True)
     created_by_role: Mapped[str] = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'account'::character varying")
+        String(255), nullable=False, server_default=db.text("'account'::character varying")
     )
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
     created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     used: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
     used_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
     used_at: Mapped[datetime | None] = mapped_column(db.DateTime, nullable=True)
-    hash: Mapped[str | None] = mapped_column(db.String(255), nullable=True)
+    hash: Mapped[str | None] = mapped_column(String(255), nullable=True)
     source_url: Mapped[str] = mapped_column(sa.TEXT, default="")
 
     def __init__(
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
     api_token_id = mapped_column(StringUUID, nullable=False)
-    path = mapped_column(db.String(255), nullable=False)
+    path: Mapped[str] = mapped_column(String(255), nullable=False)
     request = mapped_column(db.Text, nullable=True)
     response = mapped_column(db.Text, nullable=True)
-    ip = mapped_column(db.String(255), nullable=False)
+    ip: Mapped[str] = mapped_column(String(255), nullable=False)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     message_id = mapped_column(StringUUID, nullable=False)
-    type = mapped_column(db.String(255), nullable=False)
+    type: Mapped[str] = mapped_column(String(255), nullable=False)
     input = mapped_column(db.Text, nullable=True)
     output = mapped_column(db.Text, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=db.func.current_timestamp())
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     message_id = mapped_column(StringUUID, nullable=False)
     message_chain_id = mapped_column(StringUUID, nullable=True)
-    position = mapped_column(db.Integer, nullable=False)
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False)
     thought = mapped_column(db.Text, nullable=True)
     tool = mapped_column(db.Text, nullable=True)
     tool_labels_str = mapped_column(db.Text, nullable=False, server_default=db.text("'{}'::text"))
     # plugin_id = mapped_column(StringUUID, nullable=True)  ## for future design
     tool_process_data = mapped_column(db.Text, nullable=True)
     message = mapped_column(db.Text, nullable=True)
-    message_token = mapped_column(db.Integer, nullable=True)
+    message_token: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
     message_unit_price = mapped_column(db.Numeric, nullable=True)
     message_price_unit = mapped_column(db.Numeric(10, 7), nullable=False, server_default=db.text("0.001"))
     message_files = mapped_column(db.Text, nullable=True)
     answer = db.Column(db.Text, nullable=True)
-    answer_token = mapped_column(db.Integer, nullable=True)
+    answer_token: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
     answer_unit_price = mapped_column(db.Numeric, nullable=True)
     answer_price_unit = mapped_column(db.Numeric(10, 7), nullable=False, server_default=db.text("0.001"))
-    tokens = mapped_column(db.Integer, nullable=True)
+    tokens: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
     total_price = mapped_column(db.Numeric, nullable=True)
-    currency = mapped_column(db.String, nullable=True)
-    latency = mapped_column(db.Float, nullable=True)
-    created_by_role = mapped_column(db.String, nullable=False)
+    currency = mapped_column(String, nullable=True)
+    latency: Mapped[Optional[float]] = mapped_column(db.Float, nullable=True)
+    created_by_role = mapped_column(String, nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=db.func.current_timestamp())
 
 
     id = mapped_column(StringUUID, nullable=False, server_default=db.text("uuid_generate_v4()"))
     message_id = mapped_column(StringUUID, nullable=False)
-    position = mapped_column(db.Integer, nullable=False)
+    position: Mapped[int] = mapped_column(db.Integer, nullable=False)
     dataset_id = mapped_column(StringUUID, nullable=False)
     dataset_name = mapped_column(db.Text, nullable=False)
     document_id = mapped_column(StringUUID, nullable=True)
     document_name = mapped_column(db.Text, nullable=False)
     data_source_type = mapped_column(db.Text, nullable=True)
     segment_id = mapped_column(StringUUID, nullable=True)
-    score = mapped_column(db.Float, nullable=True)
+    score: Mapped[Optional[float]] = mapped_column(db.Float, nullable=True)
     content = mapped_column(db.Text, nullable=False)
-    hit_count = mapped_column(db.Integer, nullable=True)
-    word_count = mapped_column(db.Integer, nullable=True)
-    segment_position = mapped_column(db.Integer, nullable=True)
+    hit_count: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
+    word_count: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
+    segment_position: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
     index_node_hash = mapped_column(db.Text, nullable=True)
     retriever_from = mapped_column(db.Text, nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=True)
-    type = mapped_column(db.String(16), nullable=False)
-    name = mapped_column(db.String(255), nullable=False)
+    type = mapped_column(String(16), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
     created_by = mapped_column(StringUUID, nullable=False)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     app_id = mapped_column(StringUUID, nullable=False)
-    tracing_provider = mapped_column(db.String(255), nullable=True)
+    tracing_provider = mapped_column(String(255), nullable=True)
     tracing_config = mapped_column(db.JSON, nullable=True)
     created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
     updated_at = mapped_column(
         db.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
     )
-    is_active = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
+    is_active: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
 
     @property
     def tracing_config_dict(self):

api/models/provider.py

 from enum import Enum
 from typing import Optional
 
-from sqlalchemy import func, text
+from sqlalchemy import DateTime, String, func, text
 from sqlalchemy.orm import Mapped, mapped_column
 
 from .base import Base
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
     provider_type: Mapped[str] = mapped_column(
-        db.String(40), nullable=False, server_default=text("'custom'::character varying")
+        String(40), nullable=False, server_default=text("'custom'::character varying")
     )
     encrypted_config: Mapped[Optional[str]] = mapped_column(db.Text, nullable=True)
     is_valid: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=text("false"))
-    last_used: Mapped[Optional[datetime]] = mapped_column(db.DateTime, nullable=True)
+    last_used: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
 
     quota_type: Mapped[Optional[str]] = mapped_column(
-        db.String(40), nullable=True, server_default=text("''::character varying")
+        String(40), nullable=True, server_default=text("''::character varying")
     )
     quota_limit: Mapped[Optional[int]] = mapped_column(db.BigInteger, nullable=True)
     quota_used: Mapped[Optional[int]] = mapped_column(db.BigInteger, default=0)
 
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     def __repr__(self):
         return (
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
     encrypted_config: Mapped[Optional[str]] = mapped_column(db.Text, nullable=True)
     is_valid: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=text("false"))
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class TenantDefaultModel(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class TenantPreferredModelProvider(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    preferred_provider_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    preferred_provider_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class ProviderOrder(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
     account_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    payment_product_id: Mapped[str] = mapped_column(db.String(191), nullable=False)
-    payment_id: Mapped[Optional[str]] = mapped_column(db.String(191))
-    transaction_id: Mapped[Optional[str]] = mapped_column(db.String(191))
+    payment_product_id: Mapped[str] = mapped_column(String(191), nullable=False)
+    payment_id: Mapped[Optional[str]] = mapped_column(String(191))
+    transaction_id: Mapped[Optional[str]] = mapped_column(String(191))
     quantity: Mapped[int] = mapped_column(db.Integer, nullable=False, server_default=text("1"))
-    currency: Mapped[Optional[str]] = mapped_column(db.String(40))
+    currency: Mapped[Optional[str]] = mapped_column(String(40))
     total_amount: Mapped[Optional[int]] = mapped_column(db.Integer)
     payment_status: Mapped[str] = mapped_column(
-        db.String(40), nullable=False, server_default=text("'wait_pay'::character varying")
+        String(40), nullable=False, server_default=text("'wait_pay'::character varying")
     )
-    paid_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
-    pay_failed_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
-    refunded_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    paid_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
+    pay_failed_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
+    refunded_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class ProviderModelSetting(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
     enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=text("true"))
     load_balancing_enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=text("false"))
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 class LoadBalancingModelConfig(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    provider_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_name: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    model_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
-    name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    model_type: Mapped[str] = mapped_column(String(40), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
     encrypted_config: Mapped[Optional[str]] = mapped_column(db.Text, nullable=True)
     enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=text("true"))
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

api/models/source.py

 import json
+from datetime import datetime
+from typing import Optional
 
-from sqlalchemy import func
+from sqlalchemy import DateTime, String, func
 from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import Mapped, mapped_column
 
 from models.base import Base
 
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
-    access_token = mapped_column(db.String(255), nullable=False)
-    provider = mapped_column(db.String(255), nullable=False)
+    access_token: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
     source_info = mapped_column(JSONB, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    disabled = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled: Mapped[Optional[bool]] = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
 
 
 class DataSourceApiKeyAuthBinding(Base):
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id = mapped_column(StringUUID, nullable=False)
-    category = mapped_column(db.String(255), nullable=False)
-    provider = mapped_column(db.String(255), nullable=False)
+    category: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
     credentials = mapped_column(db.Text, nullable=True)  # JSON
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    disabled = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    disabled: Mapped[Optional[bool]] = mapped_column(db.Boolean, nullable=True, server_default=db.text("false"))
 
     def to_dict(self):
         return {

api/models/task.py

 from typing import Optional
 
 from celery import states  # type: ignore
+from sqlalchemy import DateTime, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from libs.datetime_utils import naive_utc_now
     __tablename__ = "celery_taskmeta"
 
     id = mapped_column(db.Integer, db.Sequence("task_id_sequence"), primary_key=True, autoincrement=True)
-    task_id = mapped_column(db.String(155), unique=True)
-    status = mapped_column(db.String(50), default=states.PENDING)
+    task_id = mapped_column(String(155), unique=True)
+    status = mapped_column(String(50), default=states.PENDING)
     result = mapped_column(db.PickleType, nullable=True)
     date_done = mapped_column(
-        db.DateTime,
+        DateTime,
         default=lambda: naive_utc_now(),
         onupdate=lambda: naive_utc_now(),
         nullable=True,
     )
     traceback = mapped_column(db.Text, nullable=True)
-    name = mapped_column(db.String(155), nullable=True)
+    name = mapped_column(String(155), nullable=True)
     args = mapped_column(db.LargeBinary, nullable=True)
     kwargs = mapped_column(db.LargeBinary, nullable=True)
-    worker = mapped_column(db.String(155), nullable=True)
-    retries = mapped_column(db.Integer, nullable=True)
-    queue = mapped_column(db.String(155), nullable=True)
+    worker = mapped_column(String(155), nullable=True)
+    retries: Mapped[Optional[int]] = mapped_column(db.Integer, nullable=True)
+    queue = mapped_column(String(155), nullable=True)
 
 
 class CeleryTaskSet(Base):
     id: Mapped[int] = mapped_column(
         db.Integer, db.Sequence("taskset_id_sequence"), autoincrement=True, primary_key=True
     )
-    taskset_id = mapped_column(db.String(155), unique=True)
+    taskset_id = mapped_column(String(155), unique=True)
     result = mapped_column(db.PickleType, nullable=True)
-    date_done: Mapped[Optional[datetime]] = mapped_column(db.DateTime, default=lambda: naive_utc_now(), nullable=True)
+    date_done: Mapped[Optional[datetime]] = mapped_column(DateTime, default=lambda: naive_utc_now(), nullable=True)

api/models/tools.py

 
 import sqlalchemy as sa
 from deprecated import deprecated
-from sqlalchemy import ForeignKey, func
+from sqlalchemy import ForeignKey, String, func
 from sqlalchemy.orm import Mapped, mapped_column
 
 from core.file import helpers as file_helpers
     )
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
-    plugin_id: Mapped[str] = mapped_column(db.String(512), nullable=False)
-    provider: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    plugin_id = mapped_column(String(512), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
     # oauth params of the tool provider
     encrypted_oauth_params: Mapped[str] = mapped_column(db.Text, nullable=False)
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # tenant id
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    plugin_id: Mapped[str] = mapped_column(db.String(512), nullable=False)
-    provider: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    plugin_id: Mapped[str] = mapped_column(String(512), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
     enabled: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("true"))
     # oauth params of the tool provider
     encrypted_oauth_params: Mapped[str] = mapped_column(db.Text, nullable=False)
     # id of the tool provider
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     name: Mapped[str] = mapped_column(
-        db.String(256), nullable=False, server_default=db.text("'API KEY 1'::character varying")
+        String(256), nullable=False, server_default=db.text("'API KEY 1'::character varying")
     )
     # id of the tenant
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=True)
     # who created this tool provider
     user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     # name of the tool provider
-    provider: Mapped[str] = mapped_column(db.String(256), nullable=False)
+    provider: Mapped[str] = mapped_column(String(256), nullable=False)
     # credential of the tool provider
     encrypted_credentials: Mapped[str] = mapped_column(db.Text, nullable=True)
     created_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
     is_default: Mapped[bool] = mapped_column(db.Boolean, nullable=False, server_default=db.text("false"))
     # credential type, e.g., "api-key", "oauth2"
     credential_type: Mapped[str] = mapped_column(
-        db.String(32), nullable=False, server_default=db.text("'api-key'::character varying")
+        String(32), nullable=False, server_default=db.text("'api-key'::character varying")
     )
     expires_at: Mapped[int] = mapped_column(db.BigInteger, nullable=False, server_default=db.text("-1"))
 
 
     id = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # name of the api provider
-    name = mapped_column(db.String(255), nullable=False, server_default=db.text("'API KEY 1'::character varying"))
+    name = mapped_column(String(255), nullable=False, server_default=db.text("'API KEY 1'::character varying"))
     # icon
-    icon = mapped_column(db.String(255), nullable=False)
+    icon: Mapped[str] = mapped_column(String(255), nullable=False)
     # original schema
     schema = mapped_column(db.Text, nullable=False)
-    schema_type_str: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    schema_type_str: Mapped[str] = mapped_column(String(40), nullable=False)
     # who created this tool
     user_id = mapped_column(StringUUID, nullable=False)
     # tenant id
     # json format credentials
     credentials_str = mapped_column(db.Text, nullable=False)
     # privacy policy
-    privacy_policy = mapped_column(db.String(255), nullable=True)
+    privacy_policy = mapped_column(String(255), nullable=True)
     # custom_disclaimer
     custom_disclaimer: Mapped[str] = mapped_column(sa.TEXT, default="")
 
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
 
     @property
     def schema_type(self) -> ApiProviderSchemaType:
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # tool id
-    tool_id: Mapped[str] = mapped_column(db.String(64), nullable=False)
+    tool_id: Mapped[str] = mapped_column(String(64), nullable=False)
     # tool type
-    tool_type: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    tool_type: Mapped[str] = mapped_column(String(40), nullable=False)
     # label name
-    label_name: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    label_name: Mapped[str] = mapped_column(String(40), nullable=False)
 
 
 class WorkflowToolProvider(Base):
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # name of the workflow provider
-    name: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
     # label of the workflow provider
-    label: Mapped[str] = mapped_column(db.String(255), nullable=False, server_default="")
+    label: Mapped[str] = mapped_column(String(255), nullable=False, server_default="")
     # icon
-    icon: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    icon: Mapped[str] = mapped_column(String(255), nullable=False)
     # app id of the workflow provider
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     # version of the workflow provider
-    version: Mapped[str] = mapped_column(db.String(255), nullable=False, server_default="")
+    version: Mapped[str] = mapped_column(String(255), nullable=False, server_default="")
     # who created this tool
     user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     # tenant id
     # parameter configuration
     parameter_configuration: Mapped[str] = mapped_column(db.Text, nullable=False, server_default="[]")
     # privacy policy
-    privacy_policy: Mapped[str] = mapped_column(db.String(255), nullable=True, server_default="")
+    privacy_policy: Mapped[str] = mapped_column(String(255), nullable=True, server_default="")
 
     created_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
 
     @property
 
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     # name of the mcp provider
-    name: Mapped[str] = mapped_column(db.String(40), nullable=False)
+    name: Mapped[str] = mapped_column(String(40), nullable=False)
     # server identifier of the mcp provider
-    server_identifier: Mapped[str] = mapped_column(db.String(64), nullable=False)
+    server_identifier: Mapped[str] = mapped_column(String(64), nullable=False)
     # encrypted url of the mcp provider
     server_url: Mapped[str] = mapped_column(db.Text, nullable=False)
     # hash of server_url for uniqueness check
-    server_url_hash: Mapped[str] = mapped_column(db.String(64), nullable=False)
+    server_url_hash: Mapped[str] = mapped_column(String(64), nullable=False)
     # icon of the mcp provider
-    icon: Mapped[str] = mapped_column(db.String(255), nullable=True)
+    icon: Mapped[str] = mapped_column(String(255), nullable=True)
     # tenant id
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     # who created this tool
     # tools
     tools: Mapped[str] = mapped_column(db.Text, nullable=False, default="[]")
     created_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
+        sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)")
     )
 
     def load_user(self) -> Account | None:
     # tenant id
     tenant_id = mapped_column(StringUUID, nullable=False)
     # provider
-    provider = mapped_column(db.String(255), nullable=False)
+    provider: Mapped[str] = mapped_column(String(255), nullable=False)
     # type
-    tool_type = mapped_column(db.String(40), nullable=False)
+    tool_type = mapped_column(String(40), nullable=False)
     # tool name
-    tool_name = mapped_column(db.String(128), nullable=False)
+    tool_name = mapped_column(String(128), nullable=False)
     # invoke parameters
     model_parameters = mapped_column(db.Text, nullable=False)
     # prompt messages
     # invoke response
     model_response = mapped_column(db.Text, nullable=False)
 
-    prompt_tokens = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
-    answer_tokens = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
+    prompt_tokens: Mapped[int] = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
+    answer_tokens: Mapped[int] = mapped_column(db.Integer, nullable=False, server_default=db.text("0"))
     answer_unit_price = mapped_column(db.Numeric(10, 4), nullable=False)
     answer_price_unit = mapped_column(db.Numeric(10, 7), nullable=False, server_default=db.text("0.001"))
     provider_response_latency = mapped_column(db.Float, nullable=False, server_default=db.text("0"))
     total_price = mapped_column(db.Numeric(10, 7))
-    currency = mapped_column(db.String(255), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    currency: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
 
 
 @deprecated
     # variables pool
     variables_str = mapped_column(db.Text, nullable=False)
 
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+    updated_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
 
     @property
     def variables(self) -> Any:
     # conversation id
     conversation_id: Mapped[str] = mapped_column(StringUUID, nullable=True)
     # file key
-    file_key: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    file_key: Mapped[str] = mapped_column(String(255), nullable=False)
     # mime type
-    mimetype: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    mimetype: Mapped[str] = mapped_column(String(255), nullable=False)
     # original url
-    original_url: Mapped[str] = mapped_column(db.String(2048), nullable=True)
+    original_url: Mapped[str] = mapped_column(String(2048), nullable=True)
     # name
     name: Mapped[str] = mapped_column(default="")
     # size
     # to describe this parameter to llm, we need this field
     query_description = mapped_column(db.Text, nullable=False)
     # query name, the name of the query parameter
-    query_name = mapped_column(db.String(40), nullable=False)
+    query_name = mapped_column(String(40), nullable=False)
     # name of the tool provider
-    tool_name = mapped_column(db.String(40), nullable=False)
+    tool_name = mapped_column(String(40), nullable=False)
     # author
-    author = mapped_column(db.String(40), nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
-    updated_at = mapped_column(db.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    author = mapped_column(String(40), nullable=False)
+    created_at = mapped_column(sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
+    updated_at = mapped_column(sa.DateTime, nullable=False, server_default=db.text("CURRENT_TIMESTAMP(0)"))
 
     @property
     def description_i18n(self) -> I18nObject:

api/models/web.py

-from sqlalchemy import func
+from datetime import datetime
+
+from sqlalchemy import DateTime, String, func
 from sqlalchemy.orm import Mapped, mapped_column
 
 from models.base import Base
     app_id = mapped_column(StringUUID, nullable=False)
     message_id = mapped_column(StringUUID, nullable=False)
     created_by_role = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'end_user'::character varying")
+        String(255), nullable=False, server_default=db.text("'end_user'::character varying")
     )
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     @property
     def message(self):
     app_id = mapped_column(StringUUID, nullable=False)
     conversation_id: Mapped[str] = mapped_column(StringUUID)
     created_by_role = mapped_column(
-        db.String(255), nullable=False, server_default=db.text("'end_user'::character varying")
+        String(255), nullable=False, server_default=db.text("'end_user'::character varying")
     )
     created_by = mapped_column(StringUUID, nullable=False)
-    created_at = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())

api/models/workflow.py

 from uuid import uuid4
 
 from flask_login import current_user
-from sqlalchemy import orm
+from sqlalchemy import DateTime, orm
 
 from core.file.constants import maybe_file_object
 from core.file.models import File
     from models.model import AppMode
 
 import sqlalchemy as sa
-from sqlalchemy import Index, PrimaryKeyConstraint, UniqueConstraint, func
+from sqlalchemy import Index, PrimaryKeyConstraint, String, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, declared_attr, mapped_column
 
 from constants import DEFAULT_FILE_NUMBER_LIMITS, HIDDEN_VALUE
     id: Mapped[str] = mapped_column(StringUUID, server_default=db.text("uuid_generate_v4()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    type: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    version: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    type: Mapped[str] = mapped_column(String(255), nullable=False)
+    version: Mapped[str] = mapped_column(String(255), nullable=False)
     marked_name: Mapped[str] = mapped_column(default="", server_default="")
     marked_comment: Mapped[str] = mapped_column(default="", server_default="")
     graph: Mapped[str] = mapped_column(sa.Text)
     _features: Mapped[str] = mapped_column("features", sa.TEXT)
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
     updated_by: Mapped[Optional[str]] = mapped_column(StringUUID)
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime,
+        DateTime,
         nullable=False,
         default=naive_utc_now(),
         server_onupdate=func.current_timestamp(),
     app_id: Mapped[str] = mapped_column(StringUUID)
 
     workflow_id: Mapped[str] = mapped_column(StringUUID)
-    type: Mapped[str] = mapped_column(db.String(255))
-    triggered_from: Mapped[str] = mapped_column(db.String(255))
-    version: Mapped[str] = mapped_column(db.String(255))
+    type: Mapped[str] = mapped_column(String(255))
+    triggered_from: Mapped[str] = mapped_column(String(255))
+    version: Mapped[str] = mapped_column(String(255))
     graph: Mapped[Optional[str]] = mapped_column(db.Text)
     inputs: Mapped[Optional[str]] = mapped_column(db.Text)
-    status: Mapped[str] = mapped_column(db.String(255))  # running, succeeded, failed, stopped, partial-succeeded
+    status: Mapped[str] = mapped_column(String(255))  # running, succeeded, failed, stopped, partial-succeeded
     outputs: Mapped[Optional[str]] = mapped_column(sa.Text, default="{}")
     error: Mapped[Optional[str]] = mapped_column(db.Text)
     elapsed_time: Mapped[float] = mapped_column(db.Float, nullable=False, server_default=sa.text("0"))
     total_tokens: Mapped[int] = mapped_column(sa.BigInteger, server_default=sa.text("0"))
     total_steps: Mapped[int] = mapped_column(db.Integer, server_default=db.text("0"), nullable=True)
-    created_by_role: Mapped[str] = mapped_column(db.String(255))  # account, end_user
+    created_by_role: Mapped[str] = mapped_column(String(255))  # account, end_user
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
-    finished_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+    finished_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
     exceptions_count: Mapped[int] = mapped_column(db.Integer, server_default=db.text("0"), nullable=True)
 
     @property
     tenant_id: Mapped[str] = mapped_column(StringUUID)
     app_id: Mapped[str] = mapped_column(StringUUID)
     workflow_id: Mapped[str] = mapped_column(StringUUID)
-    triggered_from: Mapped[str] = mapped_column(db.String(255))
+    triggered_from: Mapped[str] = mapped_column(String(255))
     workflow_run_id: Mapped[Optional[str]] = mapped_column(StringUUID)
     index: Mapped[int] = mapped_column(db.Integer)
-    predecessor_node_id: Mapped[Optional[str]] = mapped_column(db.String(255))
-    node_execution_id: Mapped[Optional[str]] = mapped_column(db.String(255))
-    node_id: Mapped[str] = mapped_column(db.String(255))
-    node_type: Mapped[str] = mapped_column(db.String(255))
-    title: Mapped[str] = mapped_column(db.String(255))
+    predecessor_node_id: Mapped[Optional[str]] = mapped_column(String(255))
+    node_execution_id: Mapped[Optional[str]] = mapped_column(String(255))
+    node_id: Mapped[str] = mapped_column(String(255))
+    node_type: Mapped[str] = mapped_column(String(255))
+    title: Mapped[str] = mapped_column(String(255))
     inputs: Mapped[Optional[str]] = mapped_column(db.Text)
     process_data: Mapped[Optional[str]] = mapped_column(db.Text)
     outputs: Mapped[Optional[str]] = mapped_column(db.Text)
-    status: Mapped[str] = mapped_column(db.String(255))
+    status: Mapped[str] = mapped_column(String(255))
     error: Mapped[Optional[str]] = mapped_column(db.Text)
     elapsed_time: Mapped[float] = mapped_column(db.Float, server_default=db.text("0"))
     execution_metadata: Mapped[Optional[str]] = mapped_column(db.Text)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, server_default=func.current_timestamp())
-    created_by_role: Mapped[str] = mapped_column(db.String(255))
+    created_at: Mapped[datetime] = mapped_column(DateTime, server_default=func.current_timestamp())
+    created_by_role: Mapped[str] = mapped_column(String(255))
     created_by: Mapped[str] = mapped_column(StringUUID)
-    finished_at: Mapped[Optional[datetime]] = mapped_column(db.DateTime)
+    finished_at: Mapped[Optional[datetime]] = mapped_column(DateTime)
 
     @property
     def created_by_account(self):
     app_id: Mapped[str] = mapped_column(StringUUID)
     workflow_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     workflow_run_id: Mapped[str] = mapped_column(StringUUID)
-    created_from: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    created_by_role: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    created_from: Mapped[str] = mapped_column(String(255), nullable=False)
+    created_by_role: Mapped[str] = mapped_column(String(255), nullable=False)
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
-    created_at: Mapped[datetime] = mapped_column(db.DateTime, nullable=False, server_default=func.current_timestamp())
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
 
     @property
     def workflow_run(self):
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False, index=True)
     data: Mapped[str] = mapped_column(db.Text, nullable=False)
     created_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=func.current_timestamp(), index=True
+        DateTime, nullable=False, server_default=func.current_timestamp(), index=True
     )
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+        DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
     )
 
     def __init__(self, *, id: str, app_id: str, conversation_id: str, data: str) -> None:
     id: Mapped[str] = mapped_column(StringUUID, primary_key=True, server_default=db.text("uuid_generate_v4()"))
 
     created_at: Mapped[datetime] = mapped_column(
-        db.DateTime,
+        DateTime,
         nullable=False,
         default=_naive_utc_datetime,
         server_default=func.current_timestamp(),
     )
 
     updated_at: Mapped[datetime] = mapped_column(
-        db.DateTime,
+        DateTime,
         nullable=False,
         default=_naive_utc_datetime,
         server_default=func.current_timestamp(),
     #
     # If it's not edited after creation, its value is `None`.
     last_edited_at: Mapped[datetime | None] = mapped_column(
-        db.DateTime,
+        DateTime,
         nullable=True,
         default=None,
     )

api/services/dataset_service.py

 
             db.session.add(segment_document)
             # update document word count
+            assert document.word_count is not None
             document.word_count += segment_document.word_count
             db.session.add(document)
             db.session.commit()
                 else:
                     keywords_list.append(None)
             # update document word count
+            assert document.word_count is not None
             document.word_count += increment_word_count
             db.session.add(document)
             try:
                 db.session.commit()
                 # update document word count
                 if word_count_change != 0:
+                    assert document.word_count is not None
                     document.word_count = max(0, document.word_count + word_count_change)
                     db.session.add(document)
                 # update segment index task
                 word_count_change = segment.word_count - word_count_change
                 # update document word count
                 if word_count_change != 0:
+                    assert document.word_count is not None
                     document.word_count = max(0, document.word_count + word_count_change)
                     db.session.add(document)
                 db.session.add(segment)
             delete_segment_from_index_task.delay([segment.index_node_id], dataset.id, document.id)
         db.session.delete(segment)
         # update document word count
+        assert document.word_count is not None
         document.word_count -= segment.word_count
         db.session.add(document)
         db.session.commit()

api/tasks/batch_create_segment_to_index_task.py

             db.session.add(segment_document)
             document_segments.append(segment_document)
         # update document word count
+        assert dataset_document.word_count is not None
         dataset_document.word_count += word_count_change
         db.session.add(dataset_document)
         # add index to db