ErisPulse 2.3.4.dev0__py3-none-any.whl → 2.3.4.dev2__py3-none-any.whl

ErisPulse/__init__.pyi

@@ -16,294 +16,7 @@ ErisPulse SDK 主模块
 {!--< /tips >!--}
 """
 
-import os
-import sys
-import types
-import importlib
-import asyncio
-import inspect
 import importlib.metadata
-from typing import Dict, List, Tuple, Type, Any, TYPE_CHECKING
-from pathlib import Path
-from .Core import Event
-from .Core import lifecycle, logger, exceptions
-from .Core import storage, env, config
-from .Core import adapter, AdapterFather, BaseAdapter, SendDSL
-from .Core import module
-from .Core import router, adapter_server
-
-sdk: SDKProtocol
-
-class LazyModule:
-    """
-    懒加载模块包装器
-    
-    当模块第一次被访问时才进行实例化
-    
-    {!--< tips >!--}
-    1. 模块的实际实例化会在第一次属性访问时进行
-    2. 依赖模块会在被使用时自动初始化
-    3. 对于继承自 BaseModule 的模块，会自动调用生命周期方法
-    {!--< /tips >!--}
-    """
-    def __init__(self: None, module_name: str, module_class: Type, sdk_ref: Any, module_info: Dict[(str, Any)]) -> None:
-        """
-        初始化懒加载包装器
-        
-        :param module_name: str 模块名称
-        :param module_class: Type 模块类
-        :param sdk_ref: Any SDK引用
-        :param module_info: Dict[str, Any] 模块信息字典
-        """
-        ...
-    async def _initialize(self: object) -> ...:
-        """
-        实际初始化模块
-        
-        :raises LazyLoadError: 当模块初始化失败时抛出
-        """
-        ...
-    def _initialize_sync(self: object) -> ...:
-        """
-        同步初始化模块，用于在异步上下文中进行同步调用
-        
-        :raises LazyLoadError: 当模块初始化失败时抛出
-        """
-        ...
-    async def _complete_async_init(self: object) -> ...:
-        """
-        完成异步初始化部分，用于同步初始化后的异步处理
-        
-        这个方法用于处理 module.load 和事件提交等异步操作
-        """
-        ...
-    def _ensure_initialized(self: object) -> None:
-        """
-        确保模块已初始化
-        
-        :raises LazyLoadError: 当模块未初始化时抛出
-        """
-        ...
-    def __getattr__(self: object, name: str) -> Any:
-        """
-        属性访问时触发初始化
-        
-        :param name: str 属性名
-        :return: Any 属性值
-        """
-        ...
-    def __setattr__(self: object, name: str, value: Any) -> None:
-        """
-        属性设置
-        
-        :param name: str 属性名
-        :param value: Any 属性值
-        """
-        ...
-    def __delattr__(self: object, name: str) -> None:
-        """
-        属性删除
-        
-        :param name: str 属性名
-        """
-        ...
-    def __getattribute__(self: object, name: str) -> Any:
-        """
-        属性访问，初始化后直接委托给实际实例
-        
-        :param name: str 属性名
-        :return: Any 属性值
-        """
-        ...
-    def __dir__(self: object) -> List[str]:
-        """
-        返回模块属性列表
-        
-        :return: List[str] 属性列表
-        """
-        ...
-    def __repr__(self: object) -> str:
-        """
-        返回模块表示字符串
-        
-        :return: str 表示字符串
-        """
-        ...
-    def __call__(self: object, *args: ..., **kwargs: ...) -> ...:
-        """
-        代理函数调用
-        """
-        ...
-
-class AdapterLoader:
-    """
-    适配器加载器
-    
-    专门用于从PyPI包加载和初始化适配器
-    
-    {!--< tips >!--}
-    1. 适配器必须通过entry-points机制注册到erispulse.adapter组
-    2. 适配器类必须继承BaseAdapter
-    3. 适配器不适用懒加载
-    {!--< /tips >!--}
-    """
-    async def load() -> Tuple[(Dict[(str, object)], List[str], List[str])]:
-        """
-        从PyPI包entry-points加载适配器
-        
-        :return: 
-            Dict[str, object]: 适配器对象字典 {适配器名: 模块对象}
-            List[str]: 启用的适配器名称列表
-            List[str]: 停用的适配器名称列表
-            
-        :raises ImportError: 当无法加载适配器时抛出
-        """
-        ...
-
-class ModuleLoader:
-    """
-    模块加载器
-    
-    专门用于从PyPI包加载和初始化普通模块
-    
-    {!--< tips >!--}
-    1. 模块必须通过entry-points机制注册到erispulse.module组
-    2. 模块类名应与entry-point名称一致
-    {!--< /tips >!--}
-    """
-    async def load() -> Tuple[(Dict[(str, object)], List[str], List[str])]:
-        """
-        从PyPI包entry-points加载模块
-        
-        :return: 
-            Dict[str, object]: 模块对象字典 {模块名: 模块对象}
-            List[str]: 启用的模块名称列表
-            List[str]: 停用的模块名称列表
-            
-        :raises ImportError: 当无法加载模块时抛出
-        """
-        ...
-    def _should_lazy_load(module_class: Type) -> bool:
-        """
-        检查模块是否应该懒加载
-        
-        :param module_class: Type 模块类
-        :return: bool 如果返回 False，则立即加载；否则懒加载
-        """
-        ...
-
-class ModuleInitializer:
-    """
-    模块初始化器（注意：适配器是一个特殊的模块）
-    
-    负责协调适配器和模块的初始化流程
-    
-    {!--< tips >!--}
-    1. 初始化顺序：适配器 → 模块
-    2. 模块初始化采用懒加载机制
-    {!--< /tips >!--}
-    """
-    async def init() -> bool:
-        """
-        初始化所有模块和适配器
-        
-        执行步骤:
-        1. 从PyPI包加载适配器
-        2. 从PyPI包加载模块
-        3. 预记录所有模块信息
-        4. 注册适配器
-        5. 初始化各模块
-        
-        :return: bool 初始化是否成功
-        :raises InitError: 当初始化失败时抛出
-        """
-        ...
-
-async def init_progress() -> bool:
-    """
-    初始化项目环境文件
-    
-    1. 检查并创建main.py入口文件
-    2. 确保基础目录结构存在
-    
-    :return: bool 是否创建了新的main.py文件
-    
-    {!--< tips >!--}
-    1. 如果main.py已存在则不会覆盖
-    2. 此方法通常由SDK内部调用
-    {!--< /tips >!--}
-    """
-    ...
-
-async def init() -> bool:
-    """
-    SDK初始化入口
-    
-    :return: bool SDK初始化是否成功
-    """
-    ...
-
-def init_sync() -> bool:
-    """
-    SDK初始化入口（同步版本）
-    
-    用于命令行直接调用，自动在事件循环中运行异步初始化
-    
-    :return: bool SDK初始化是否成功
-    """
-    ...
-
-def init_task() -> asyncio.Task:
-    """
-    SDK初始化入口，返回Task对象
-    
-    :return: asyncio.Task 初始化任务
-    """
-    ...
-
-async def uninit() -> bool:
-    """
-    SDK反初始化
-    
-    执行以下操作：
-    1. 关闭所有适配器
-    2. 卸载所有模块
-    3. 清理所有事件处理器
-    4. 清理僵尸线程
-    
-    :return: bool 反初始化是否成功
-    """
-    ...
-
-async def restart() -> bool:
-    """
-    SDK重新启动
-    
-    执行完整的反初始化后再初始化过程
-    
-    :return: bool 重新加载是否成功
-    """
-    ...
-
-async def run(keep_running: bool = ...) -> None:
-    """
-    无头模式运行ErisPulse
-    
-    此方法提供了一种无需入口启动的方式，适用于与其它框架集成的场景
-    """
-    ...
-
-async def load_module(module_name: str) -> bool:
-    """
-    手动加载指定模块
-    
-    :param module_name: str 要加载的模块名称
-    :return: bool 加载是否成功
-    
-    {!--< tips >!--}
-    1. 可用于手动触发懒加载模块的初始化
-    2. 如果模块不存在或已加载会返回False
-    3. 对于需要异步初始化的模块，这是唯一的加载方式
-    {!--< /tips >!--}
-    """
-    ...
+from .Core import Event, lifecycle, logger, exceptions, storage, env, config, adapter, AdapterFather, BaseAdapter, SendDSL, module, router, adapter_server
+from .sdk import sdk
+from .loaders.module_loader import LazyModule

ErisPulse/__main__.py

@@ -3,7 +3,7 @@ ErisPulse SDK 命令行工具
 
 提供ErisPulse生态系统的包管理、模块控制和开发工具功能。
 """
-from .utils import CLI
+from .CLI import CLI
 
 def main():
     """

ErisPulse/__main__.pyi

@@ -10,7 +10,7 @@ ErisPulse SDK 命令行工具
 提供ErisPulse生态系统的包管理、模块控制和开发工具功能。
 """
 
-from .utils import CLI
+from .CLI import CLI
 
 def main() -> ...:
     """

ErisPulse/loaders/__init__.py

@@ -0,0 +1,22 @@
+"""
+ErisPulse 加载器模块
+
+提供适配器和模块的加载功能
+
+{!--< tips >!--}
+1. 此模块由 SDK 内部使用
+2. 一般不需要手动导入这些加载器
+{!--< /tips >!--}
+"""
+
+from .adapter_loader import AdapterLoader
+from .module_loader import ModuleLoader
+from .initializer import Initializer
+from .strategy import ModuleLoadStrategy
+
+__all__ = [
+    "AdapterLoader",
+    "ModuleLoader",
+    "Initializer",
+    "ModuleLoadStrategy",
+]

ErisPulse/loaders/__init__.pyi

@@ -0,0 +1,21 @@
+# type: ignore
+#
+# Auto-generated type stub for __init__.py
+# DO NOT EDIT MANUALLY - Generated by generate-type-stubs.py
+#
+
+"""
+ErisPulse 加载器模块
+
+提供适配器和模块的加载功能
+
+{!--< tips >!--}
+1. 此模块由 SDK 内部使用
+2. 一般不需要手动导入这些加载器
+{!--< /tips >!--}
+"""
+
+from .adapter_loader import AdapterLoader
+from .module_loader import ModuleLoader
+from .initializer import Initializer
+from .strategy import ModuleLoadStrategy

ErisPulse/loaders/adapter_loader.py

@@ -0,0 +1,187 @@
+"""
+ErisPulse 适配器加载器
+
+专门用于从 PyPI 包加载和初始化适配器
+
+{!--< tips >!--}
+1. 适配器必须通过 entry-points 机制注册到 erispulse.adapter 组
+2. 适配器类必须继承 BaseAdapter
+3. 适配器不适用懒加载
+{!--< /tips >!--}
+"""
+
+import sys
+import asyncio
+import importlib.metadata
+from typing import Dict, List, Any, Tuple
+from .base_loader import BaseLoader
+from ..Core.logger import logger
+from ..Core.lifecycle import lifecycle
+
+class AdapterLoader(BaseLoader):
+    """
+    适配器加载器
+    
+    负责从 PyPI entry-points 加载适配器
+    
+    {!--< tips >!--}
+    使用方式：
+    >>> loader = AdapterLoader()
+    >>> adapter_objs, enabled, disabled = await loader.load(adapter_manager)
+    {!--< /tips >!--}
+    """
+    
+    def __init__(self):
+        """初始化适配器加载器"""
+        super().__init__("ErisPulse.adapters")
+    
+    def _get_entry_point_group(self) -> str:
+        """
+        获取 entry-point 组名
+        
+        :return: "erispulse.adapter"
+        """
+        return "erispulse.adapter"
+    
+    async def _process_entry_point(
+        self,
+        entry_point: Any,
+        objs: Dict[str, Any],
+        enabled_list: List[str],
+        disabled_list: List[str],
+        manager_instance: Any
+    ) -> Tuple[Dict[str, Any], List[str], List[str]]:
+        """
+        处理单个适配器 entry-point
+        
+        :param entry_point: entry-point 对象
+        :param objs: 适配器对象字典
+        :param enabled_list: 启用的适配器列表
+        :param disabled_list: 停用的适配器列表
+        :param manager_instance: 适配器管理器实例
+        
+        :return: 
+            Dict[str, Any]: 更新后的适配器对象字典
+            List[str]: 更新后的启用适配器列表 
+            List[str]: 更新后的禁用适配器列表
+            
+        :raises ImportError: 当适配器加载失败时抛出
+        """
+        meta_name = entry_point.name
+        
+        # 检查适配器是否已经注册，如果未注册则进行注册（默认启用）
+        if not manager_instance.exists(meta_name):
+            manager_instance._config_register(meta_name, True)
+            logger.info(f"发现新适配器 {meta_name}，默认已启用")
+        
+        # 获取适配器当前状态
+        adapter_status = manager_instance.is_enabled(meta_name)
+        logger.debug(f"适配器 {meta_name} 状态: {adapter_status}")
+        
+        if not adapter_status:
+            disabled_list.append(meta_name)
+            logger.debug(f"适配器 {meta_name} 已禁用，跳过...")
+            return objs, enabled_list, disabled_list
+        
+        try:
+            loaded_class = entry_point.load()
+            adapter_obj = sys.modules[loaded_class.__module__]
+            dist = importlib.metadata.distribution(entry_point.dist.name)
+            
+            adapter_info = {
+                "meta": {
+                    "name": meta_name,
+                    "version": getattr(adapter_obj, "__version__", dist.version if dist else "1.0.0"),
+                    "description": getattr(adapter_obj, "__description__", ""),
+                    "author": getattr(adapter_obj, "__author__", ""),
+                    "license": getattr(adapter_obj, "__license__", ""),
+                    "package": entry_point.dist.name
+                },
+                "adapter_class": loaded_class
+            }
+            
+            if not hasattr(adapter_obj, 'adapterInfo'):
+                setattr(adapter_obj, 'adapterInfo', {})
+                
+            adapter_obj.adapterInfo[meta_name] = adapter_info
+                
+            objs[meta_name] = adapter_obj
+            enabled_list.append(meta_name)
+            logger.debug(f"从 PyPI 包发现适配器: {meta_name}")
+            
+        except Exception as e:
+            logger.warning(f"从 entry-point 加载适配器 {meta_name} 失败: {e}")
+            raise ImportError(f"无法加载适配器 {meta_name}: {e}")
+            
+        return objs, enabled_list, disabled_list
+    
+    async def register_to_manager(
+        self,
+        adapters: List[str],
+        adapter_objs: Dict[str, Any],
+        manager_instance: Any
+    ) -> bool:
+        """
+        将适配器注册到管理器
+        
+        :param adapters: 适配器名称列表
+        :param adapter_objs: 适配器对象字典
+        :param manager_instance: 适配器管理器实例
+        :return: 适配器注册是否成功
+        
+        {!--< tips >!--}
+        此方法由初始化协调器调用
+        {!--< /tips >!--}
+        """
+        # 并行注册所有适配器
+        register_tasks = []
+        
+        for adapter_name in adapters:
+            adapter_obj = adapter_objs[adapter_name]
+            
+            async def register_single_adapter(name: str, obj: Any) -> bool:
+                """注册单个适配器"""
+                try:
+                    success = True
+                    if hasattr(obj, "adapterInfo") and isinstance(obj.adapterInfo, dict):
+                        for platform, adapter_info in obj.adapterInfo.items():
+                            # 使用管理器的方法检查是否已存在
+                            if platform in manager_instance._adapters:
+                                continue
+                                
+                            adapter_class = adapter_info["adapter_class"]
+                            
+                            # 调用管理器的 register 方法
+                            manager_instance.register(platform, adapter_class, adapter_info)
+                            logger.info(f"注册适配器: {platform} ({adapter_class.__name__})")
+                            
+                            # 提交适配器加载完成事件
+                            await lifecycle.submit_event(
+                                "adapter.load",
+                                msg=f"适配器 {platform} 加载完成",
+                                data={
+                                    "platform": platform,
+                                    "success": True
+                                }
+                            )
+                    return success
+                except Exception as e:
+                    logger.error(f"适配器 {name} 注册失败: {e}")
+                    # 提交适配器加载失败事件
+                    await lifecycle.submit_event(
+                        "adapter.load",
+                        msg=f"适配器 {name} 加载失败: {e}",
+                        data={
+                            "platform": name,
+                            "success": False
+                        }
+                    )
+                    return False
+            
+            register_tasks.append(register_single_adapter(adapter_name, adapter_obj))
+        
+        # 等待所有注册任务完成
+        register_results = await asyncio.gather(*register_tasks, return_exceptions=True)
+        
+        # 检查是否有注册失败的情况
+        return not any(isinstance(result, Exception) or result is False for result in register_results)

ErisPulse/loaders/adapter_loader.pyi

@@ -0,0 +1,82 @@
+# type: ignore
+#
+# Auto-generated type stub for adapter_loader.py
+# DO NOT EDIT MANUALLY - Generated by generate-type-stubs.py
+#
+
+"""
+ErisPulse 适配器加载器
+
+专门用于从 PyPI 包加载和初始化适配器
+
+{!--< tips >!--}
+1. 适配器必须通过 entry-points 机制注册到 erispulse.adapter 组
+2. 适配器类必须继承 BaseAdapter
+3. 适配器不适用懒加载
+{!--< /tips >!--}
+"""
+
+import sys
+import asyncio
+import importlib.metadata
+from typing import Dict, List, Any, Tuple
+from .base_loader import BaseLoader
+from ..Core.logger import logger
+from ..Core.lifecycle import lifecycle
+
+class AdapterLoader(BaseLoader):
+    """
+    适配器加载器
+    
+    负责从 PyPI entry-points 加载适配器
+    
+    {!--< tips >!--}
+    使用方式：
+    >>> loader = AdapterLoader()
+    >>> adapter_objs, enabled, disabled = await loader.load(adapter_manager)
+    {!--< /tips >!--}
+    """
+    def __init__(self: None) -> ...:
+        """
+        初始化适配器加载器
+        """
+        ...
+    def _get_entry_point_group(self: object) -> str:
+        """
+        获取 entry-point 组名
+        
+        :return: "erispulse.adapter"
+        """
+        ...
+    async def _process_entry_point(self: object, entry_point: Any, objs: Dict[(str, Any)], enabled_list: List[str], disabled_list: List[str], manager_instance: Any) -> Tuple[(Dict[(str, Any)], List[str], List[str])]:
+        """
+        处理单个适配器 entry-point
+        
+        :param entry_point: entry-point 对象
+        :param objs: 适配器对象字典
+        :param enabled_list: 启用的适配器列表
+        :param disabled_list: 停用的适配器列表
+        :param manager_instance: 适配器管理器实例
+        
+        :return: 
+            Dict[str, Any]: 更新后的适配器对象字典
+            List[str]: 更新后的启用适配器列表 
+            List[str]: 更新后的禁用适配器列表
+            
+        :raises ImportError: 当适配器加载失败时抛出
+        """
+        ...
+    async def register_to_manager(self: object, adapters: List[str], adapter_objs: Dict[(str, Any)], manager_instance: Any) -> bool:
+        """
+        将适配器注册到管理器
+        
+        :param adapters: 适配器名称列表
+        :param adapter_objs: 适配器对象字典
+        :param manager_instance: 适配器管理器实例
+        :return: 适配器注册是否成功
+        
+        {!--< tips >!--}
+        此方法由初始化协调器调用
+        {!--< /tips >!--}
+        """
+        ...