Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

4.2 KB
Raw Blame
"""Metadata use cases with explicit ownership and persistence contracts."""

from collections.abc import Sequence
from dataclasses import dataclass
from datetime import datetime
from typing import Protocol, TypedDict

from core.rag.index_processor.constant.built_in_field import BuiltInField
from machinery.context import RequestContext
from services.knowledge.dataset_access import DatasetAccess
from services.knowledge.resource_scope import DatasetRef


class MetadataInput(Protocol):
    @property
    def name(self) -> str: ...
    @property
    def type(self) -> str: ...


class MetadataValue(Protocol):
    @property
    def id(self) -> str: ...
    @property
    def value(self) -> str | int | float | None: ...


class MetadataOperation(Protocol):
    @property
    def document_id(self) -> str: ...
    @property
    def metadata_list(self) -> Sequence[MetadataValue]: ...
    @property
    def partial_update(self) -> bool: ...


class MetadataOperationsInput(Protocol):
    @property
    def operation_data(self) -> Sequence[MetadataOperation]: ...


@dataclass(frozen=True)
class MetadataRecord:
    id: str
    name: str
    type: str
    tenant_id: str
    dataset_id: str
    created_by: str
    created_at: datetime
    updated_by: str | None
    updated_at: datetime | None


class MetadataFieldSummary(TypedDict):
    id: str
    name: str
    type: str
    count: int


class MetadataList(TypedDict):
    doc_metadata: list[MetadataFieldSummary]
    built_in_field_enabled: bool


class MetadataStore(Protocol):
    """Own bounded transactions and recheck the complete dataset owner chain."""

    def create(self, ref: DatasetRef, *, name: str, field_type: str, actor_id: str) -> MetadataRecord: ...
    def rename(self, ref: DatasetRef, metadata_id: str, *, name: str, actor_id: str) -> MetadataRecord: ...
    def delete(self, ref: DatasetRef, metadata_id: str) -> MetadataRecord: ...
    def set_built_in(self, ref: DatasetRef, *, enabled: bool) -> None: ...
    def update_documents(self, ref: DatasetRef, operations: Sequence[MetadataOperation], *, actor_id: str) -> None: ...
    def list_fields(self, ref: DatasetRef) -> MetadataList: ...


class MetadataService:
    def __init__(self, *, store: MetadataStore, dataset_access: DatasetAccess) -> None:
        self._store = store
        self._access = dataset_access

    def require_dataset(self, context: RequestContext, dataset_id: str) -> DatasetRef:
        dataset = self._access.require_accessible(context, dataset_id)
        return DatasetRef(dataset.workspace_id, dataset.id)

    @staticmethod
    def _validate_name(name: str) -> None:
        if len(name) > 255:
            raise ValueError("Metadata name cannot exceed 255 characters.")
        if name in BuiltInField:
            raise ValueError("Metadata name already exists in Built-in fields.")

    def create_metadata(self, ref: DatasetRef, args: MetadataInput, *, actor_id: str) -> MetadataRecord:
        self._validate_name(args.name)
        return self._store.create(ref, name=args.name, field_type=args.type, actor_id=actor_id)

    def update_metadata_name(self, ref: DatasetRef, metadata_id: str, name: str, *, actor_id: str) -> MetadataRecord:
        self._validate_name(name)
        return self._store.rename(ref, metadata_id, name=name, actor_id=actor_id)

    def delete_metadata(self, ref: DatasetRef, metadata_id: str) -> MetadataRecord:
        return self._store.delete(ref, metadata_id)

    @staticmethod
    def get_built_in_fields() -> list[dict[str, str]]:
        return [
            {
                "name": field.value,
                "type": "time" if field in (BuiltInField.upload_date, BuiltInField.last_update_date) else "string",
            }
            for field in BuiltInField
        ]

    def enable_built_in_field(self, ref: DatasetRef) -> None:
        self._store.set_built_in(ref, enabled=True)

    def disable_built_in_field(self, ref: DatasetRef) -> None:
        self._store.set_built_in(ref, enabled=False)

    def update_documents_metadata(self, ref: DatasetRef, args: MetadataOperationsInput, *, actor_id: str) -> None:
        self._store.update_documents(ref, args.operation_data, actor_id=actor_id)

    def get_dataset_metadatas(self, ref: DatasetRef) -> MetadataList:
        return self._store.list_fields(ref)