deepdata: core product code (backend, frontend, runtime, deepflow module)

2026-08-30 19:23:38 +08:00
commit bd3db30be9
1405 changed files with 271727 additions and 0 deletions
@@ -0,0 +1,15 @@
+"""
+Operator Market Repositories
+算子市场数据访问层
+"""
+from .operator_repository import OperatorRepository
+from .category_repository import CategoryRepository
+from .category_relation_repository import CategoryRelationRepository
+from .operator_release_repository import OperatorReleaseRepository
+
+__all__ = [
+    "OperatorRepository",
+    "CategoryRepository",
+    "CategoryRelationRepository",
+    "OperatorReleaseRepository",
+]
@@ -0,0 +1,77 @@
+"""
+Category Relation Repository
+分类关系数据访问层
+"""
+from typing import List
+
+from sqlalchemy import select, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models.operator import CategoryRelation
+from app.module.operator.constants import CATEGORY_PREDEFINED_ID
+
+
+class CategoryRelationRepository:
+    """分类关系数据访问层"""
+
+    def __init__(self, model: CategoryRelation):
+        self.model = model
+
+    async def find_all(self, db: AsyncSession) -> List[CategoryRelation]:
+        """查询所有分类关系"""
+        result = await db.execute(select(CategoryRelation))
+        return result.scalars().all()
+
+    async def batch_insert(
+        self,
+        operator_id: str,
+        category_ids: List[str],
+        db: AsyncSession
+    ) -> None:
+        """批量插入分类关系"""
+        for category_id in category_ids:
+            entity = CategoryRelation(
+                category_id=category_id,
+                operator_id=operator_id
+            )
+            db.add(entity)
+
+    async def batch_update(
+        self,
+        operator_id: str,
+        category_ids: List[str],
+        db: AsyncSession
+    ) -> None:
+        """批量更新分类关系（先删除后插入）"""
+        # Delete existing relations
+        await db.execute(
+            delete(CategoryRelation)
+            .where(CategoryRelation.operator_id == operator_id)
+        )
+        # Insert new relations
+        for category_id in category_ids:
+            entity = CategoryRelation(
+                category_id=category_id,
+                operator_id=operator_id
+            )
+            db.add(entity)
+
+    async def delete_by_operator_id(self, operator_id: str, db: AsyncSession) -> None:
+        """根据算子ID删除分类关系"""
+        await db.execute(
+            delete(CategoryRelation)
+            .where(CategoryRelation.operator_id == operator_id)
+        )
+
+    async def operator_is_predefined(self, operator_id: str, db: AsyncSession) -> bool:
+        """检查算子是否为预定义算子"""
+        result = await db.execute(
+            select(CategoryRelation)
+            .where(
+                and_(
+                    CategoryRelation.operator_id == operator_id,
+                    CategoryRelation.category_id == CATEGORY_PREDEFINED_ID
+                )
+            )
+        )
+        return result.first() is not None
@@ -0,0 +1,23 @@
+"""
+Category Repository
+分类数据访问层
+"""
+from typing import List
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models.operator import Category
+from app.module.operator.schema import CategoryDto
+
+
+class CategoryRepository:
+    """分类数据访问层"""
+
+    def __init__(self, model: Category):
+        self.model = model
+
+    async def find_all(self, db: AsyncSession) -> List[Category]:
+        """查询所有分类"""
+        result = await db.execute(select(Category))
+        return result.scalars().all()
@@ -0,0 +1,72 @@
+"""
+Operator Release Repository
+算子发布版本数据访问层
+"""
+from typing import List
+
+from sqlalchemy import select, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models.operator import OperatorRelease
+from app.module.operator.schema import OperatorReleaseDto
+
+
+class OperatorReleaseRepository:
+    """算子发布版本数据访问层"""
+
+    def __init__(self, model: OperatorRelease):
+        self.model = model
+
+    async def find_all_by_operator_id(
+        self,
+        operator_id: str,
+        db: AsyncSession
+    ) -> List[OperatorRelease]:
+        """查询算子的所有发布版本"""
+        result = await db.execute(
+            select(OperatorRelease)
+            .where(OperatorRelease.id == operator_id)
+            .order_by(OperatorRelease.release_date.desc())
+        )
+        return result.scalars().all()
+
+    async def insert(
+        self,
+        dto: OperatorReleaseDto,
+        db: AsyncSession
+    ) -> None:
+        """插入发布版本"""
+        entity = OperatorRelease(
+            id=dto.id,
+            version=dto.version,
+            release_date=dto.release_date,
+            changelog=dto.changelog
+        )
+        db.add(entity)
+
+    async def update(
+        self,
+        dto: OperatorReleaseDto,
+        db: AsyncSession
+    ) -> None:
+        """更新发布版本"""
+        result = await db.execute(
+            select(OperatorRelease)
+            .where(
+                and_(
+                    OperatorRelease.id == dto.id,
+                    OperatorRelease.version == dto.version
+                )
+            )
+        )
+        entity = result.scalar_one_or_none()
+        if entity:
+            entity.changelog = dto.changelog
+            entity.release_date = dto.release_date
+
+    async def delete(self, operator_id: str, db: AsyncSession) -> None:
+        """删除算子的所有发布版本"""
+        await db.execute(
+            delete(OperatorRelease)
+            .where(OperatorRelease.id == operator_id)
+        )
@@ -0,0 +1,121 @@
+"""
+Operator Repository
+算子数据访问层
+"""
+import json
+from typing import List, Optional
+from datetime import datetime, timezone
+
+from sqlalchemy import select, text, update, func
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.db.models.operator import Operator
+from app.module.operator.schema import OperatorDto
+
+
+class OperatorRepository:
+    """算子数据访问层"""
+
+    def __init__(self, model: Operator):
+        self.model = model
+
+    async def find_all(self, db: AsyncSession) -> List[Operator]:
+        """查询所有算子"""
+        result = await db.execute(select(Operator))
+        return result.scalars().all()
+
+    async def insert(self, dto: OperatorDto, db: AsyncSession) -> None:
+        """插入算子"""
+        entity = Operator(
+            id=dto.id,
+            name=dto.name,
+            description=dto.description,
+            version=dto.version,
+            inputs=dto.inputs,
+            outputs=dto.outputs,
+            runtime=dto.runtime,
+            settings=dto.settings,
+            file_name=dto.file_name,
+            file_size=dto.file_size,
+            metrics=dto.metrics,
+            usage_count=dto.usage_count or 0,
+            is_star=dto.is_star or False,
+        )
+        db.add(entity)
+
+    async def update(self, dto: OperatorDto, db: AsyncSession) -> None:
+        """更新算子"""
+        await db.execute(
+            update(Operator)
+            .where(Operator.id == dto.id)
+            .values(
+                name=dto.name,
+                description=dto.description,
+                version=dto.version,
+                inputs=dto.inputs,
+                outputs=dto.outputs,
+                runtime=dto.runtime,
+                settings=dto.settings,
+                file_name=dto.file_name,
+                file_size=dto.file_size,
+                metrics=dto.metrics,
+                is_star=dto.is_star,
+                updated_at=datetime.utcnow(),
+            )
+        )
+
+    async def delete(self, operator_id: str, db: AsyncSession) -> None:
+        """删除算子"""
+        entity = await db.get(Operator, operator_id)
+        if entity:
+            await db.delete(entity)
+
+    async def count_by_star(self, is_star: bool, db: AsyncSession) -> int:
+        """统计收藏算子数量"""
+        result = await db.execute(
+            select(text("COUNT(*)"))
+            .select_from(Operator)
+            .where(Operator.is_star == is_star)
+        )
+        return result.scalar() or 0
+
+    async def operator_in_template(self, operator_id: str, db: AsyncSession) -> bool:
+        """检查算子是否在模板中"""
+        result = await db.execute(
+            text("""
+                SELECT COUNT(*) FROM t_operator_instance oi
+                JOIN t_clean_template t ON oi.instance_id = t.id
+                WHERE oi.operator_id = :operator_id
+            """),
+            {"operator_id": operator_id}
+        )
+        return (result.scalar() or 0) > 0
+
+    async def operator_in_unstop_task(self, operator_id: str, db: AsyncSession) -> bool:
+        """检查算子是否在未完成的任务中"""
+        result = await db.execute(
+            text("""
+                SELECT COUNT(*) FROM t_operator_instance oi
+                JOIN t_clean_task t ON oi.instance_id = t.id
+                WHERE oi.operator_id = :operator_id AND t.status != 'COMPLETED'
+            """),
+            {"operator_id": operator_id}
+        )
+        return (result.scalar() or 0) > 0
+
+    async def increment_usage_count(
+        self,
+        operator_ids: List[str],
+        db: AsyncSession
+    ) -> None:
+        """增加算子使用次数"""
+        if not operator_ids:
+            return
+        await db.execute(
+            update(Operator)
+            .where(Operator.id.in_(operator_ids))
+            .values(
+                usage_count=func.coalesce(Operator.usage_count, 0) + 1,
+                updated_at=datetime.utcnow(),
+            )
+        )