清理代码

sync_state_machine/datasource/__init__.py

@@ -25,9 +25,6 @@ from .task_result import TaskResult, TaskStatus
 # API DataSource
 from .api import ApiClient, ApiDataSource, BaseApiHandler, register as register_api_datasource
 
-# DB base helpers
-from .db import DbDataSource, BaseDbHandler
-
 # JSONL DataSource  
 from .jsonl import JsonlDataSource, BaseJsonlHandler, register as register_jsonl_datasource
 
@@ -65,10 +62,6 @@ __all__ = [
     "ApiDataSource",
     "BaseApiHandler",
 
-    # DB base helpers
-    "DbDataSource",
-    "BaseDbHandler",
-    
     # JSONL DataSource
     "JsonlDataSource",
     "BaseJsonlHandler",

sync_state_machine/datasource/api/datasource.py

@@ -12,7 +12,7 @@ import json
 from typing import Optional
 from pathlib import Path
 from ..datasource import BaseDataSource
-from ..handler import NodeHandler, ensure_handler_compat
+from ..handler import NodeHandler
 from ..task_result import TaskResult
 from .client import ApiClient
 
@@ -72,16 +72,15 @@ class ApiDataSource(BaseDataSource):
         Args:
             handler: API Handler 实例
         """
-        compatible_handler = ensure_handler_compat(handler)
-        compatible_handler.set_api_client(self.client)
-        compatible_handler.set_poll_mode(self.poll_mode)
+        handler.set_api_client(self.client)
+        handler.set_poll_mode(self.poll_mode)
         
         # 调用基类注册方法
-        super().register_handler(compatible_handler)
+        super().register_handler(handler)
 
         # 如果 collection 已设置，确保新 handler 拿到引用
         if self._collection is not None:
-            compatible_handler.set_collection(self._collection)  # type: ignore[arg-type]
+            handler.set_collection(self._collection)  # type: ignore[arg-type]
 
     @staticmethod
     def _fmt_trace_value(value, max_len: int = 600) -> str:

sync_state_machine/datasource/datasource.py

@@ -31,7 +31,6 @@ if TYPE_CHECKING:
 
 from ..common.types import SyncStatus
 from ..common.type_safety import get_pydantic_model_fields
-from .handler import ensure_handler_compat
 from .task_result import TaskResult
 from ..engine import (
     StateMachineConfig,
@@ -379,9 +378,8 @@ class BaseDataSource(ABC):
         示例：
             datasource.register_handler(ContractNodeHandler(api_client))
         """
-        compatible_handler = ensure_handler_compat(handler)
-        self._handlers[compatible_handler.node_type] = compatible_handler
-        self._apply_target_project_ids_to_handler(compatible_handler)
+        self._handlers[handler.node_type] = handler
+        self._apply_target_project_ids_to_handler(handler)
 
     def set_target_project_ids(self, target_project_ids: Optional[List[str]]) -> None:
         """设置项目过滤列表，并在注册阶段下发给所有 handler。"""

sync_state_machine/datasource/db/__init__.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-"""DB DataSource 基类模块。"""
-
-from .datasource import DbDataSource
-from .handler import BaseDbHandler
-
-__all__ = ["DbDataSource", "BaseDbHandler"]

sync_state_machine/datasource/db/datasource.py

@@ -1,22 +0,0 @@
-"""DbDataSource - 数据库数据源协调层。"""
-
-from __future__ import annotations
-
-from ..datasource import BaseDataSource
-
-
-class DbDataSource(BaseDataSource):
-    """基于数据库 Handler 的数据源实现。"""
-
-    async def close(self) -> None:
-        return None
-
-    def _on_node_loaded(self, handler, node) -> None:
-        node.append_log(
-            f"DB链路[load] node_type={node.node_type} data_id={node.data_id or '<empty>'}"
-        )
-
-    def _on_in_progress_result(self, handler, node, result) -> None:
-        node.append_log(
-            f"DB链路[submit] action={node.action.value} data_id={node.data_id or '<empty>'}"
-        )

sync_state_machine/datasource/db/handler.py

@@ -1,68 +0,0 @@
-"""BaseDbHandler - DB Handler 基类。"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional, Set, TypeVar, TYPE_CHECKING
-
-from pydantic import BaseModel
-
-from ...common.type_safety import get_pydantic_model_fields
-from ..handler import BaseNodeHandler
-
-if TYPE_CHECKING:
-    from ...common.sync_node import SyncNode
-    from .datasource import DbDataSource
-
-T = TypeVar("T", bound=BaseModel)
-
-
-class BaseDbHandler(BaseNodeHandler[T]):
-    """数据库 Handler 基类。"""
-
-    def __init__(
-        self,
-        datasource: "DbDataSource",
-        node_type: str,
-        node_class: type["SyncNode[T]"],
-        schema: type[T],
-    ):
-        super().__init__(node_type, node_class, schema)
-        self.datasource = datasource
-        self.update_schemas: List[type] = []
-        self._target_project_ids: Optional[Set[str]] = None
-
-    def set_target_project_ids(self, target_project_ids: List[str]) -> None:
-        if target_project_ids:
-            self._target_project_ids = {str(item) for item in target_project_ids if str(item)}
-        else:
-            self._target_project_ids = None
-
-    def get_update_fields(self, *, exclude: frozenset = frozenset({"id"})) -> List[str]:
-        fields: set[str] = set()
-        for schema in self.update_schemas:
-            for field_name in get_pydantic_model_fields(schema):
-                if field_name not in exclude:
-                    fields.add(field_name)
-        return sorted(fields)
-
-    def _create_basic_node(self, data: Dict[str, Any], depend_ids: Optional[List[str]] = None) -> "SyncNode[T]":
-        data_id = self.extract_id(data)
-        if self._collection is None:
-            raise RuntimeError("Collection not set. Call set_collection() before creating nodes.")
-
-        if data_id:
-            existing_node = self._collection.get_by_data_id(self.node_type, data_id)
-            if existing_node is not None:
-                existing_node.depend_ids = list(depend_ids or [])
-                existing_node.set_data(data.copy())
-                existing_node.set_origin_data(data.copy())
-                return existing_node
-
-        node_id = self._collection.generate_node_id()
-        return self.node_class(
-            node_id=node_id,
-            data_id=data_id,
-            data=data.copy(),
-            depend_ids=depend_ids or [],
-            origin_data=data.copy(),
-        )

sync_state_machine/datasource/handler.py

@@ -479,87 +479,6 @@ class BaseNodeHandler(ABC, Generic[T]):
         return self.create_node(data)
 
 
-class CompatibleNodeHandler(Generic[T]):
-    """兼容旧式 Handler，实现扩展后的可选接口并委托给原对象。"""
-
-    def __init__(self, handler: NodeHandler[T]):
-        self._handler = handler
-
-    @property
-    def node_type(self) -> str:
-        return self._handler.node_type
-
-    @property
-    def node_class(self) -> Type["SyncNode[T]"]:
-        return self._handler.node_class
-
-    @property
-    def schema(self) -> Type[T]:
-        return self._handler.schema
-
-    def set_collection(self, collection: "DataCollection") -> None:
-        self._handler.set_collection(collection)
-
-    def set_handler_config(self, config: Dict[str, Any]) -> None:
-        method = getattr(self._handler, "set_handler_config", None)
-        if callable(method):
-            method(config)
-
-    def set_target_project_ids(self, target_project_ids: List[str]) -> None:
-        method = getattr(self._handler, "set_target_project_ids", None)
-        if callable(method):
-            method(target_project_ids)
-
-    def set_api_client(self, client: "ApiClient") -> None:
-        method = getattr(self._handler, "set_api_client", None)
-        if callable(method):
-            method(client)
-
-    def set_poll_mode(self, mode: str) -> None:
-        method = getattr(self._handler, "set_poll_mode", None)
-        if callable(method):
-            method(mode)
-
-    def get_update_fields(self, *, exclude: frozenset[str] = frozenset({"id"})) -> List[str]:
-        method = getattr(self._handler, "get_update_fields", None)
-        if callable(method):
-            return method(exclude=exclude)
-        return []
-
-    async def load(self) -> List["SyncNode"]:
-        return await self._handler.load()
-
-    async def create_all(self, nodes: List["SyncNode"]) -> List[TaskResult]:
-        return await self._handler.create_all(nodes)
-
-    async def update_all(self, nodes: List["SyncNode"]) -> List[TaskResult]:
-        return await self._handler.update_all(nodes)
-
-    async def delete_all(self, nodes: List["SyncNode"]) -> List[TaskResult]:
-        return await self._handler.delete_all(nodes)
-
-    async def poll_tasks(self, task_ids: List[str]) -> Dict[str, TaskResult]:
-        return await self._handler.poll_tasks(task_ids)
-
-    async def validate(self, data: Dict[str, Any]) -> ValidationResult:
-        return await self._handler.validate(data)
-
-    def extract_id(self, data: Dict[str, Any]) -> str:
-        return self._handler.extract_id(data)
-
-    def _create_node(self, data: Dict[str, Any]) -> "SyncNode[T]":
-        return self._handler._create_node(data)
-
-    def __getattr__(self, item: str) -> Any:
-        return getattr(self._handler, item)
-
-
-def ensure_handler_compat(handler: NodeHandler[T]) -> NodeHandler[T]:
-    if isinstance(handler, BaseNodeHandler) or isinstance(handler, CompatibleNodeHandler):
-        return handler
-    return CompatibleNodeHandler(handler)
-
-
 class NodeHandlerRegistry:
     """节点处理器注册表"""