From 623582b7d2a71a4400e9b3ac34428229ac681c84 Mon Sep 17 00:00:00 2001 From: Ultronen <1594778171@qq.com> Date: Sat, 19 Sep 2026 00:44:00 +0800 Subject: [PATCH 1/3] test(dataset): update available_segment_count test to use explicit session --- .../models/test_dataset_models.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/api/tests/test_containers_integration_tests/models/test_dataset_models.py b/api/tests/test_containers_integration_tests/models/test_dataset_models.py index d817894b1dede3..52d9b42c3563d6 100644 --- a/api/tests/test_containers_integration_tests/models/test_dataset_models.py +++ b/api/tests/test_containers_integration_tests/models/test_dataset_models.py @@ -132,7 +132,7 @@ def test_dataset_word_count_aggregation(self, db_session_with_containers: Sessio db_session_with_containers.add(doc) db_session_with_containers.flush() - assert dataset.word_count == 5000 + assert dataset.get_word_count(session=db_session_with_containers) == 5000 def test_dataset_available_segment_count(self, db_session_with_containers: Session) -> None: """Test Dataset.available_segment_count counts completed and enabled segments.""" @@ -188,7 +188,7 @@ def test_dataset_available_segment_count(self, db_session_with_containers: Sessi db_session_with_containers.add(seg_waiting) db_session_with_containers.flush() - assert dataset.available_segment_count == 2 + assert dataset.get_available_segment_count(session=db_session_with_containers) == 2 def test_document_segment_count_property(self, db_session_with_containers: Session) -> None: """Test document can count its segments.""" @@ -228,7 +228,7 @@ def test_document_segment_count_property(self, db_session_with_containers: Sessi db_session_with_containers.add(seg) db_session_with_containers.flush() - assert doc.segment_count == 3 + assert doc.get_segment_count(session=db_session_with_containers) == 3 def test_document_hit_count_aggregation(self, db_session_with_containers: Session) -> None: """Test document can aggregate hit count from segments.""" @@ -269,7 +269,7 @@ def test_document_hit_count_aggregation(self, db_session_with_containers: Sessio db_session_with_containers.add(seg) db_session_with_containers.flush() - assert doc.hit_count == 25 + assert doc.get_hit_count(session=db_session_with_containers) == 25 class TestDocumentSegmentNavigationProperties: @@ -322,7 +322,7 @@ def test_document_segment_dataset_property(self, db_session_with_containers: Ses db_session_with_containers.flush() # Act - related_dataset = segment.dataset + related_dataset = segment.get_dataset(session=db_session_with_containers) # Assert assert related_dataset is not None @@ -369,7 +369,7 @@ def test_document_segment_document_property(self, db_session_with_containers: Se db_session_with_containers.flush() # Act - related_document = segment.document + related_document = segment.get_document(session=db_session_with_containers) # Assert assert related_document is not None From 787aa3b34a0644f1c520223831140ce06e2a1cba Mon Sep 17 00:00:00 2001 From: Ultronen <1594778171@qq.com> Date: Sat, 19 Sep 2026 00:44:20 +0800 Subject: [PATCH 2/3] refactor(dataset): replace available_segment_count property with get_available_segment_count(session) --- api/models/dataset.py | 277 +++++------------------------------------- 1 file changed, 32 insertions(+), 245 deletions(-) diff --git a/api/models/dataset.py b/api/models/dataset.py index ddcc8020ed84ac..41e86b2d0c028b 100644 --- a/api/models/dataset.py +++ b/api/models/dataset.py @@ -96,67 +96,6 @@ class DatasetBindingItem(TypedDict): name: str -class ExternalKnowledgeApiDict(TypedDict): - id: str - tenant_id: str - name: str - description: str - settings: dict[str, Any] | None - dataset_bindings: list[DatasetBindingItem] - created_by: str - created_at: str - - -class DocumentDict(TypedDict): - id: str - tenant_id: str - dataset_id: str - position: int - data_source_type: str - data_source_info: str | None - dataset_process_rule_id: str | None - batch: str - name: str - created_from: str - created_by: str - created_api_request_id: str | None - created_at: datetime - processing_started_at: datetime | None - file_id: str | None - word_count: int | None - parsing_completed_at: datetime | None - cleaning_completed_at: datetime | None - splitting_completed_at: datetime | None - tokens: int | None - indexing_latency: float | None - completed_at: datetime | None - is_paused: bool | None - paused_by: str | None - paused_at: datetime | None - error: str | None - stopped_at: datetime | None - indexing_status: str - enabled: bool - disabled_at: datetime | None - disabled_by: str | None - archived: bool - archived_reason: str | None - archived_by: str | None - archived_at: datetime | None - updated_at: datetime - doc_type: str | None - doc_metadata: Any - doc_form: IndexStructureType - doc_language: str | None - display_status: str | None - data_source_info_dict: dict[str, Any] - average_segment_length: int - dataset_process_rule: ProcessRuleDict | None - dataset: None - segment_count: int | None - hit_count: int | None - - from models.enums import PermissionEnum # Backward-compatible alias — new code should import PermissionEnum from models.enums @@ -202,15 +141,15 @@ class Dataset(Base): collection_binding_id = mapped_column(StringUUID, nullable=True) retrieval_model = mapped_column(AdjustedJSON, nullable=True) summary_index_setting = mapped_column(AdjustedJSON, nullable=True) - built_in_field_enabled = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false")) + built_in_field_enabled = mapped_column(sa.Boolean, nullable=False, server_default=sa.false()) icon_info = mapped_column(AdjustedJSON, nullable=True) runtime_mode = mapped_column( EnumText(DatasetRuntimeMode, length=255), nullable=True, server_default=sa.text("'general'") ) pipeline_id = mapped_column(StringUUID, nullable=True) chunk_structure = mapped_column(sa.String(255), nullable=True) - enable_api = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true")) - is_multimodal = mapped_column(sa.Boolean, default=False, nullable=False, server_default=sa.text("false")) + enable_api = mapped_column(sa.Boolean, nullable=False, server_default=sa.true()) + is_multimodal = mapped_column(sa.Boolean, default=False, nullable=False, server_default=sa.false()) def get_total_documents(self, *, session: Session) -> int: return self.get_document_count(session=session) @@ -243,10 +182,6 @@ def external_retrieval_model(self): } return self.retrieval_model or default_retrieval_model - @property - def created_by_account(self): - return self.get_created_by_account(session=db.session()) - def get_created_by_account(self, *, session: Session) -> Account | None: return session.get(Account, self.created_by) @@ -264,10 +199,6 @@ def get_latest_process_rule(self, *, session: Session) -> "DatasetProcessRule | .limit(1) ) - @property - def app_count(self) -> int: - return self.get_app_count(session=db.session()) - def get_app_count(self, *, session: Session) -> int: return ( session.scalar( @@ -278,17 +209,12 @@ def get_app_count(self, *, session: Session) -> int: or 0 ) - @property - def document_count(self) -> int: - return self.get_document_count(session=db.session()) - def get_document_count(self, *, session: Session) -> int: return session.scalar(select(func.count(Document.id)).where(Document.dataset_id == self.id)) or 0 - @property - def available_document_count(self): + def get_available_document_count(self, *, session: Session) -> int: return ( - db.session.scalar( + session.scalar( select(func.count(Document.id)).where( Document.dataset_id == self.id, Document.indexing_status == "completed", @@ -299,10 +225,9 @@ def available_document_count(self): or 0 ) - @property - def available_segment_count(self): + def get_available_segment_count(self, *, session: Session) -> int: return ( - db.session.scalar( + session.scalar( select(func.count(DocumentSegment.id)).where( DocumentSegment.dataset_id == self.id, DocumentSegment.status == "completed", @@ -312,10 +237,6 @@ def available_segment_count(self): or 0 ) - @property - def word_count(self) -> int: - return self.get_word_count(session=db.session()) - def get_word_count(self, *, session: Session) -> int: return ( session.scalar( @@ -324,10 +245,6 @@ def get_word_count(self, *, session: Session) -> int: or 0 ) - @property - def doc_form(self) -> str | None: - return self.get_doc_form(session=db.session()) - def get_doc_form(self, *, session: Session) -> str | None: if self.chunk_structure: return self.chunk_structure @@ -357,10 +274,6 @@ def retrieval_model_dict(self): return {**default_retrieval_model, **self.retrieval_model} - @property - def tags(self) -> Sequence[Tag]: - return self.get_tags(session=db.session()) - def get_tags(self, *, session: Session) -> Sequence[Tag]: tags = session.scalars( select(Tag) @@ -392,6 +305,16 @@ def get_external_knowledge_info(self, *, session: Session) -> dict[str, Any] | N ExternalKnowledgeApis.tenant_id == self.tenant_id, ) ) + return self.build_external_knowledge_info(external_knowledge_binding, external_knowledge_api) + + @staticmethod + def build_external_knowledge_info( + external_knowledge_binding: "ExternalKnowledgeBindings | None", + external_knowledge_api: "ExternalKnowledgeApis | None", + ) -> dict[str, Any] | None: + """Format an external knowledge binding and its API into the response payload.""" + if external_knowledge_binding is None: + return None if external_knowledge_api is None or external_knowledge_api.settings is None: return None return { @@ -401,10 +324,6 @@ def get_external_knowledge_info(self, *, session: Session) -> dict[str, Any] | N "external_knowledge_api_endpoint": json.loads(external_knowledge_api.settings).get("endpoint", ""), } - @property - def is_published(self) -> bool: - return self.get_is_published(session=db.session()) - def get_is_published(self, *, session: Session) -> bool: if self.pipeline_id: pipeline = session.scalar(select(Pipeline).where(Pipeline.id == self.pipeline_id)) @@ -412,13 +331,13 @@ def get_is_published(self, *, session: Session) -> bool: return pipeline.is_published return False - @property - def doc_metadata(self) -> list[dict[str, str]]: - return self.get_doc_metadata(session=db.session()) - def get_doc_metadata(self, *, session: Session) -> list[dict[str, str]]: dataset_metadatas = session.scalars(select(DatasetMetadata).where(DatasetMetadata.dataset_id == self.id)).all() + return self.build_doc_metadata(dataset_metadatas) + + def build_doc_metadata(self, dataset_metadatas: "Sequence[DatasetMetadata]") -> list[dict[str, str]]: + """Format metadata rows, appending the built-in fields when they are enabled.""" doc_metadata = [ { "id": dataset_metadata.id, @@ -560,7 +479,7 @@ class Document(Base): completed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True) # pause - is_paused: Mapped[bool | None] = mapped_column(sa.Boolean, nullable=True, server_default=sa.text("false")) + is_paused: Mapped[bool | None] = mapped_column(sa.Boolean, nullable=True, server_default=sa.false()) paused_by = mapped_column(StringUUID, nullable=True) paused_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True) @@ -572,10 +491,10 @@ class Document(Base): indexing_status = mapped_column( EnumText(IndexingStatus, length=255), nullable=False, server_default=sa.text("'waiting'") ) - enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true")) + enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.true()) disabled_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True) disabled_by = mapped_column(StringUUID, nullable=True) - archived: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false")) + archived: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false()) archived_reason = mapped_column(String(255), nullable=True) archived_by = mapped_column(StringUUID, nullable=True) archived_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True) @@ -588,7 +507,7 @@ class Document(Base): EnumText(IndexStructureType, length=255), nullable=False, server_default=sa.text("'text_model'") ) doc_language = mapped_column(String(255), nullable=True) - need_summary: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false")) + need_summary: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false()) DATA_SOURCES = ["upload_file", "notion_import", "website_crawl"] @@ -622,10 +541,6 @@ def data_source_info_dict(self) -> dict[str, Any]: return data_source_info_dict return {} - @property - def data_source_detail_dict(self) -> dict[str, Any]: - return self.get_data_source_detail_dict(session=db.session()) - def get_data_source_detail_dict(self, *, session: Session) -> dict[str, Any]: if self.data_source_info: if self.data_source_type == "upload_file": @@ -650,40 +565,18 @@ def get_data_source_detail_dict(self, *, session: Session) -> dict[str, Any]: return result return {} - @property - def average_segment_length(self): - if self.word_count and self.word_count != 0 and self.segment_count and self.segment_count != 0: - return self.word_count // self.segment_count - return 0 - - @property - def dataset_process_rule(self): - return self.get_dataset_process_rule(session=db.session()) - def get_dataset_process_rule(self, *, session: Session) -> "DatasetProcessRule | None": if self.dataset_process_rule_id: return session.get(DatasetProcessRule, self.dataset_process_rule_id) return None - @property - def dataset(self) -> Dataset | None: - return self.get_dataset(session=db.session()) - def get_dataset(self, *, session: Session) -> Dataset | None: """Load the owning dataset with the caller-owned database session.""" return session.get(Dataset, self.dataset_id) - @property - def segment_count(self): - return self.get_segment_count(session=db.session()) - def get_segment_count(self, *, session: Session) -> int: return session.scalar(select(func.count(DocumentSegment.id)).where(DocumentSegment.document_id == self.id)) or 0 - @property - def hit_count(self): - return self.get_hit_count(session=db.session()) - def get_hit_count(self, *, session: Session) -> int: return ( session.scalar( @@ -694,10 +587,6 @@ def get_hit_count(self, *, session: Session) -> int: or 0 ) - @property - def uploader(self): - return self.get_uploader(session=db.session()) - def get_uploader(self, *, session: Session) -> str | None: user = session.scalar(select(Account).where(Account.id == self.created_by)) return user.name if user else None @@ -710,10 +599,6 @@ def upload_date(self): def last_update_date(self): return self.updated_at - @property - def doc_metadata_details(self) -> list[DocMetadataDetailItem] | None: - return self.get_doc_metadata_details(session=db.session()) - def get_doc_metadata_details(self, *, session: Session) -> list[DocMetadataDetailItem] | None: if self.doc_metadata: document_metadatas = session.scalars( @@ -742,12 +627,6 @@ def get_doc_metadata_details(self, *, session: Session) -> list[DocMetadataDetai return metadata_list return None - @property - def process_rule_dict(self) -> ProcessRuleDict | None: - if self.dataset_process_rule_id and self.dataset_process_rule: - return self.dataset_process_rule.to_dict() - return None - def get_built_in_fields(self, *, session: Session) -> list[DocMetadataDetailItem]: built_in_fields: list[DocMetadataDetailItem] = [] built_in_fields.append( @@ -792,58 +671,6 @@ def get_built_in_fields(self, *, session: Session) -> list[DocMetadataDetailItem ) return built_in_fields - def to_dict(self) -> DocumentDict: - result: DocumentDict = { - "id": self.id, - "tenant_id": self.tenant_id, - "dataset_id": self.dataset_id, - "position": self.position, - "data_source_type": self.data_source_type, - "data_source_info": self.data_source_info, - "dataset_process_rule_id": self.dataset_process_rule_id, - "batch": self.batch, - "name": self.name, - "created_from": self.created_from, - "created_by": self.created_by, - "created_api_request_id": self.created_api_request_id, - "created_at": self.created_at, - "processing_started_at": self.processing_started_at, - "file_id": self.file_id, - "word_count": self.word_count, - "parsing_completed_at": self.parsing_completed_at, - "cleaning_completed_at": self.cleaning_completed_at, - "splitting_completed_at": self.splitting_completed_at, - "tokens": self.tokens, - "indexing_latency": self.indexing_latency, - "completed_at": self.completed_at, - "is_paused": self.is_paused, - "paused_by": self.paused_by, - "paused_at": self.paused_at, - "error": self.error, - "stopped_at": self.stopped_at, - "indexing_status": self.indexing_status, - "enabled": self.enabled, - "disabled_at": self.disabled_at, - "disabled_by": self.disabled_by, - "archived": self.archived, - "archived_reason": self.archived_reason, - "archived_by": self.archived_by, - "archived_at": self.archived_at, - "updated_at": self.updated_at, - "doc_type": self.doc_type, - "doc_metadata": self.doc_metadata, - "doc_form": self.doc_form, - "doc_language": self.doc_language, - "display_status": self.display_status, - "data_source_info_dict": self.data_source_info_dict, - "average_segment_length": self.average_segment_length, - "dataset_process_rule": self.dataset_process_rule.to_dict() if self.dataset_process_rule else None, - "dataset": None, - "segment_count": self.segment_count, - "hit_count": self.hit_count, - } - return result - @classmethod def from_dict(cls, data: dict[str, Any]): return cls( @@ -917,7 +744,7 @@ class DocumentSegment(TypeBase): # indexing fields index_node_id: Mapped[str | None] = mapped_column(String(255), nullable=True, default=None) index_node_hash: Mapped[str | None] = mapped_column(String(255), nullable=True, default=None) - enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"), default=True) + enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.true(), default=True) answer: Mapped[str | None] = mapped_column(LongText, nullable=True, default=None) keywords: Mapped[Any] = mapped_column(sa.JSON, nullable=True, default=None) disabled_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, default=None) @@ -938,18 +765,10 @@ class DocumentSegment(TypeBase): stopped_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, default=None) hit_count: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0) - @property - def dataset(self) -> Dataset | None: - return self.get_dataset(session=db.session()) - def get_dataset(self, *, session: Session) -> Dataset | None: """Load the owning dataset with the caller-owned database session.""" return session.get(Dataset, self.dataset_id) - @property - def document(self) -> Document | None: - return self.get_document(session=db.session()) - def get_document(self, *, session: Session) -> Document | None: """Load the owning document with the caller-owned database session.""" return session.get(Document, self.document_id) @@ -968,10 +787,6 @@ def next_segment(self, session: Session) -> "DocumentSegment | None": ) ) - @property - def child_chunks(self): - return self.get_child_chunks(session=db.session(), include_full_doc=False) - def get_child_chunks(self, *, session: Session, include_full_doc: bool = True) -> Sequence["ChildChunk"]: """Load hierarchical child chunks with the caller-owned database session.""" document = session.get(Document, self.document_id) @@ -1058,10 +873,6 @@ def get_sign_content(self) -> str: return text - @property - def attachments(self) -> list[AttachmentItem]: - return self.get_attachments(session=db.session()) - def get_attachments(self, *, session: Session) -> list[AttachmentItem]: """Load attachment metadata with the caller-owned database session.""" # Use JOIN to fetch attachments in a single query instead of two separate queries @@ -1211,10 +1022,6 @@ class DatasetQuery(TypeBase): DateTime, nullable=False, server_default=sa.func.current_timestamp(), init=False ) - @property - def queries(self) -> list[dict[str, Any]]: - return self.get_queries(session=db.session()) - def get_queries(self, *, session: Session) -> list[dict[str, Any]]: try: queries = json.loads(self.content) @@ -1378,7 +1185,7 @@ class TidbAuthBinding(TypeBase): tenant_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True) 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(sa.Boolean, nullable=False, server_default=sa.text("false")) + active: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false()) status: Mapped[TidbAuthBindingStatus] = mapped_column( EnumText(TidbAuthBindingStatus, length=255), nullable=False, server_default=sa.text("'CREATING'") ) @@ -1429,9 +1236,7 @@ class DatasetPermission(TypeBase): dataset_id: Mapped[str] = mapped_column(StringUUID, nullable=False) account_id: Mapped[str] = mapped_column(StringUUID, nullable=False) tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False) - has_permission: Mapped[bool] = mapped_column( - sa.Boolean, nullable=False, server_default=sa.text("true"), default=True - ) + has_permission: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.true(), default=True) created_at: Mapped[datetime] = mapped_column( DateTime, nullable=False, server_default=func.current_timestamp(), init=False ) @@ -1465,18 +1270,6 @@ class ExternalKnowledgeApis(TypeBase): DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False ) - def to_dict(self) -> ExternalKnowledgeApiDict: - return { - "id": self.id, - "tenant_id": self.tenant_id, - "name": self.name, - "description": self.description, - "settings": self.settings_dict, - "dataset_bindings": self.dataset_bindings, - "created_by": self.created_by, - "created_at": self.created_at.isoformat(), - } - @property def settings_dict(self) -> dict[str, Any] | None: try: @@ -1484,10 +1277,6 @@ def settings_dict(self) -> dict[str, Any] | None: except JSONDecodeError: return None - @property - def dataset_bindings(self) -> list[DatasetBindingItem]: - return self.get_dataset_bindings(session=db.session()) - def get_dataset_bindings(self, *, session: Session) -> list[DatasetBindingItem]: external_knowledge_bindings = session.scalars( select(ExternalKnowledgeBindings).where(ExternalKnowledgeBindings.external_knowledge_api_id == self.id) @@ -1547,7 +1336,7 @@ class DatasetAutoDisableLog(TypeBase): tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False) dataset_id: Mapped[str] = mapped_column(StringUUID, nullable=False) document_id: Mapped[str] = mapped_column(StringUUID, nullable=False) - notified: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"), default=False) + notified: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false(), default=False) created_at: Mapped[datetime] = mapped_column( DateTime, nullable=False, server_default=sa.func.current_timestamp(), init=False ) @@ -1703,10 +1492,8 @@ class Pipeline(TypeBase): name: Mapped[str] = mapped_column(sa.String(255), nullable=False) description: Mapped[str] = mapped_column(LongText, nullable=False, default=sa.text("''")) workflow_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None) - is_public: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"), default=False) - is_published: Mapped[bool] = mapped_column( - sa.Boolean, nullable=False, server_default=sa.text("false"), default=False - ) + is_public: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false(), default=False) + is_published: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.false(), default=False) created_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None) created_at: Mapped[datetime] = mapped_column( sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False @@ -1830,7 +1617,7 @@ class DocumentSegmentSummary(TypeBase): default=SummaryStatus.GENERATING, ) error: Mapped[str | None] = mapped_column(LongText, nullable=True, default=None) - enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"), default=True) + enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.true(), default=True) disabled_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, default=None) disabled_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None) created_at: Mapped[datetime] = mapped_column( From caa263410c97e5c46c3252aca0edc588200096e6 Mon Sep 17 00:00:00 2001 From: "autofix-ci[bot]" <114827586+autofix-ci[bot]@users.noreply.github.com> Date: Fri, 18 Sep 2026 18:40:13 +0000 Subject: [PATCH 3/3] [autofix.ci] apply automated fixes --- api/models/dataset.py | 1 - 1 file changed, 1 deletion(-) diff --git a/api/models/dataset.py b/api/models/dataset.py index 41e86b2d0c028b..d149d7c0d462ad 100644 --- a/api/models/dataset.py +++ b/api/models/dataset.py @@ -29,7 +29,6 @@ from .account import Account from .base import Base, TypeBase -from .engine import db from .enums import ( CollectionBindingType, CreatorUserRole,