ErisPulse 1.0.0__zip

erispulse-1.0.0/ErisPulse/envManager.py

@@ -0,0 +1,202 @@
+import os
+import json
+import sqlite3
+import importlib.util
+from pathlib import Path
+
+class EnvManager:
+    _instance = None
+    db_path = "./config.db"
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, "_initialized"):
+            self._init_db()
+    
+    def _init_db(self):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS config (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+        )
+        """)
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS modules (
+            module_name TEXT PRIMARY KEY,
+            status INTEGER NOT NULL,
+            version TEXT,
+            description TEXT,
+            author TEXT,
+            dependencies TEXT,
+            optional_dependencies TEXT
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def get(self, key, default=None):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT value FROM config WHERE key = ?", (key,))
+                result = cursor.fetchone()
+            if result:
+                try:
+                    return json.loads(result[0])
+                except json.JSONDecodeError:
+                    return result[0]
+            return default
+        except sqlite3.OperationalError as e:
+            if "no such table" in str(e):
+                self._init_db()
+                return self.get(key, default)
+            else:
+                raise
+
+    def set(self, key, value):
+        serialized_value = json.dumps(value) if isinstance(value, (dict, list)) else str(value)
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)", (key, serialized_value))
+        conn.commit()
+        conn.close()
+
+    def delete(self, key):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM config WHERE key = ?", (key,))
+        conn.commit()
+        conn.close()
+    
+    def clear(self):
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM config")
+        conn.commit()
+        conn.close()
+
+    def load_env_file(self):
+        env_file = Path("env.py")
+        if env_file.exists():
+            spec = importlib.util.spec_from_file_location("env_module", env_file)
+            env_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(env_module)
+            for key, value in vars(env_module).items():
+                if not key.startswith("__") and isinstance(value, (dict, list, str, int, float, bool)):
+                    self.set(key, value)
+    def set_module_status(self, module_name, status):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+            UPDATE modules SET status = ? WHERE module_name = ?
+            """, (int(status), module_name))
+            conn.commit()
+    
+    def get_module_status(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+            SELECT status FROM modules WHERE module_name = ?
+            """, (module_name,))
+            result = cursor.fetchone()
+            return bool(result[0]) if result else True
+    
+    def set_all_modules(self, modules_info):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            for module_name, module_info in modules_info.items():
+                cursor.execute("""
+                INSERT OR REPLACE INTO modules (
+                    module_name, status, version, description, author, dependencies, optional_dependencies
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    module_name,
+                    int(module_info.get('status', True)),
+                    module_info.get('info', {}).get('version', ''),
+                    module_info.get('info', {}).get('description', ''),
+                    module_info.get('info', {}).get('author', ''),
+                    json.dumps(module_info.get('info', {}).get('dependencies', [])),
+                    json.dumps(module_info.get('info', {}).get('optional_dependencies', []))
+                ))
+            conn.commit()
+
+    def get_all_modules(self):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM modules")
+            rows = cursor.fetchall()
+            modules_info = {}
+            for row in rows:
+                module_name, status, version, description, author, dependencies, optional_dependencies = row
+                modules_info[module_name] = {
+                    'status': bool(status),
+                    'info': {
+                        'version': version,
+                        'description': description,
+                        'author': author,
+                        'dependencies': json.loads(dependencies) if dependencies else [],
+                        'optional_dependencies': json.loads(optional_dependencies) if optional_dependencies else []
+                    }
+                }
+            return modules_info
+
+    def get_module(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM modules WHERE module_name = ?", (module_name,))
+            row = cursor.fetchone()
+            if row:
+                module_name, status, version, description, author, dependencies, optional_dependencies = row
+                return {
+                    'status': bool(status),
+                    'info': {
+                        'version': version,
+                        'description': description,
+                        'author': author,
+                        'dependencies': json.loads(dependencies) if dependencies else [],
+                        'optional_dependencies': json.loads(optional_dependencies) if optional_dependencies else []
+                    }
+                }
+            return None
+
+    def set_module(self, module_name, module_info):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+            INSERT OR REPLACE INTO modules (
+                module_name, status, version, description, author, dependencies, optional_dependencies
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (
+                module_name,
+                int(module_info.get('status', True)),
+                module_info.get('info', {}).get('version', ''),
+                module_info.get('info', {}).get('description', ''),
+                module_info.get('info', {}).get('author', ''),
+                json.dumps(module_info.get('info', {}).get('dependencies', [])),
+                json.dumps(module_info.get('info', {}).get('optional_dependencies', []))
+            ))
+            conn.commit()
+
+    def update_module(self, module_name, module_info):
+        self.set_module(module_name, module_info)
+
+    def remove_module(self, module_name):
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM modules WHERE module_name = ?", (module_name,))
+            conn.commit()
+            return cursor.rowcount > 0
+    
+    def __getattr__(self, key):
+        try:
+            return self.get(key)
+        except KeyError:
+            raise AttributeError(f"配置项 {key} 不存在")
+
+env = EnvManager()

erispulse-1.0.0/ErisPulse/errors.py

@@ -0,0 +1,16 @@
+class CycleDependencyError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidDependencyError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+class InvalidModuleError(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

erispulse-1.0.0/ErisPulse/logger.py

@@ -0,0 +1,71 @@
+import logging
+import inspect
+from . import sdk
+from .envManager import env
+
+_logger = logging.getLogger("RyhBot")
+_log_level = env.get("LOG_LEVEL", "DEBUG")
+if _log_level is None:
+    _log_level = logging.DEBUG
+_logger.setLevel(_log_level)
+
+if not _logger.handlers:
+    log_format = (
+        f"[%(asctime)s] "
+        f"[%(levelname)s] "
+        f"%(message)s"
+    )
+    color_map = {
+        "DEBUG": "\033[94m",
+        "INFO": "\033[92m",
+        "WARNING": "\033[93m",
+        "ERROR": "\033[91m",
+        "CRITICAL": "\033[95m",
+        "RESET": "\033[0m",
+    }
+
+    class ColoredFormatter(logging.Formatter):
+        def format(self, record):
+            levelname = record.levelname
+            if levelname in color_map:
+                record.levelname = (
+                    f"{color_map[levelname]}{levelname}{color_map['RESET']}"
+                )
+            return super().format(record)
+
+    console_handler = logging.StreamHandler()
+    date_format = "%y/%m/%d-%H:%M:%S"
+    formatter = ColoredFormatter(log_format, datefmt=date_format)
+    console_handler.setFormatter(formatter)
+    _logger.addHandler(console_handler)
+
+
+def _get_caller():
+    frame = inspect.currentframe().f_back.f_back
+    module = inspect.getmodule(frame)
+    module_name = module.__name__
+    if module_name == "__main__":
+        module_name = "Main"
+    if module_name.endswith(".Core"):
+        module_name = module_name[:-5]
+    return module_name
+
+def debug(msg, *args, **kwargs):
+    caller_module = _get_caller()
+    _logger.debug(f"[{caller_module}] {msg}", *args, **kwargs)
+
+def info(msg, *args, **kwargs):
+    caller_module = _get_caller()
+    _logger.info(f"[{caller_module}] {msg}", *args, **kwargs)
+
+def warning(msg, *args, **kwargs):
+    caller_module = _get_caller()
+    _logger.warning(f"[{caller_module}] {msg}", *args, **kwargs)
+
+def error(msg, *args, **kwargs):
+    caller_module = _get_caller()
+    _logger.error(f"[{caller_module}] {msg}", *args, **kwargs)
+
+def critical(msg, *args, **kwargs):
+    caller_module = _get_caller()
+    _logger.critical(f"[{caller_module}] {msg}", *args, **kwargs)

erispulse-1.0.0/ErisPulse/origin.py

@@ -0,0 +1,112 @@
+import asyncio
+import aiohttp
+from .envManager import env
+
+class OriginManager:
+    def __init__(self):
+        self._init_origins()
+
+    def _init_origins(self):
+        if not env.get('origins'):
+            env.set('origins', [])
+
+    async def _validate_url(self, url):
+        if not url.startswith(('http://', 'https://')):
+            protocol = input("未指定协议，请输入使用的协议 (http 或 https): ").strip().lower()
+            if protocol not in ['http', 'https']:
+                print("无效的协议类型，必须是 http 或 https。")
+                return None
+            url = f"{protocol}://{url}"
+        
+        if not url.endswith('.json'):
+            url = f"{url}/map.json"
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    response.raise_for_status()
+                    if response.headers.get('Content-Type', '').startswith('application/json'):
+                        return url
+                    else:
+                        print(f"源 {url} 返回的内容不是有效的 JSON 格式。")
+                        return None
+        except Exception as e:
+            print(f"访问源 {url} 失败: {e}")
+            return None
+
+
+    def add_origin(self, value):
+        validated_url = asyncio.run(self._validate_url(value))
+        if not validated_url:
+            print("提供的源不是一个有效源，请检查后重试。")
+            return
+
+        origins = env.get('origins')
+        if validated_url not in origins:
+            origins.append(validated_url)
+            env.set('origins', origins)
+            print(f"源 {validated_url} 已成功添加。")
+        else:
+            print(f"源 {validated_url} 已存在，无需重复添加。")
+
+    def update_origins(self):
+        origins = env.get('origins')
+        providers = {}
+        modules = {}
+        module_alias = {}
+        
+        print("\033[1m{:<10} | {:<20} | {:<50}\033[0m".format("源", "模块", "地址"))
+        print("-" * 85)
+
+        async def fetch_origin_data():
+            async with aiohttp.ClientSession() as session:
+                for origin in origins:
+                    print(f"\n\033[94m正在获取 {origin}\033[0m")
+                    try:
+                        async with session.get(origin) as response:
+                            response.raise_for_status()
+                            if response.headers.get('Content-Type', '').startswith('application/json'):
+                                content = await response.json()
+                                providers[content["name"]] = content["base"]
+                                
+                                for module in list(content["modules"].keys()):
+                                    module_content = content["modules"][module]
+                                    modules[f'{module}@{content["name"]}'] = module_content
+                                    module_origin_name = module_content["path"]
+                                    module_alias_name = module
+                                    module_alias[f'{module_origin_name}@{content["name"]}'] = module_alias_name
+
+                                    print("{:<10} | {:<20} | {:<50}".format(
+                                        content['name'], 
+                                        module, 
+                                        f"{providers[content['name']]}{module_origin_name}"
+                                    ))
+                            else:
+                                print(f"\033[91m源 {origin} 返回的内容不是有效的 JSON 格式。\033[0m")
+                    except Exception as e:
+                        print(f"\033[91m获取 {origin} 时出错: {e}\033[0m")
+
+        # 使用 asyncio.run 调用异步任务
+        asyncio.run(fetch_origin_data())
+
+        env.set('providers', providers)
+        env.set('modules', modules)
+        env.set('module_alias', module_alias)
+        
+        print("\n\033[92m{}\033[0m".format("完成".center(85, "-")))
+
+    def list_origins(self):
+        origins = env.get('origins')
+        for origin in origins:
+            print(origin)
+
+    def del_origin(self, value):
+        origins = env.get('origins')
+        if value in origins:
+            origins.remove(value)
+            env.set('origins', origins)
+            print(f"源 {value} 已删除。")
+        else:
+            print(f"源 {value} 不存在。")
+
+origin_manager = OriginManager()

erispulse-1.0.0/ErisPulse/sdk.py

@@ -0,0 +1,3 @@
+
+if __name__ == "__main__":
+    print("别删我哦 (｡•́︿•̀｡) ，我超级有用呢！")

erispulse-1.0.0/ErisPulse/util.py

@@ -0,0 +1,30 @@
+from collections import defaultdict, deque
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+executor = ThreadPoolExecutor()
+
+
+def topological_sort(elements, dependencies, error):
+    graph = defaultdict(list)
+    in_degree = {element: 0 for element in elements}
+    for element, deps in dependencies.items():
+        for dep in deps:
+            graph[dep].append(element)
+            in_degree[element] += 1
+    queue = deque([element for element in elements if in_degree[element] == 0])
+    sorted_list = []
+    while queue:
+        node = queue.popleft()
+        sorted_list.append(node)
+        for neighbor in graph[node]:
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+    if len(sorted_list) != len(elements):
+        raise error(f"Cycle detected in the dependencies: {elements} -> {dependencies}")
+    return sorted_list
+
+def ExecAsync(async_func, *args, **kwargs):
+    loop = asyncio.get_event_loop()
+    return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))

erispulse-1.0.0/ErisPulse.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: ErisPulse
+Version: 1.0.0
+Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+Home-page: https://github.com/wsu2059q/ErisPulse
+Author: 艾莉丝·格雷拉特(WSu2059)&r1a
+Author-email: wsu2059@qq.com&dev@oneall.eu.org
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ErisPulse
+
+本项目基于 [RyhBotPythonSDK V2](https://github.com/runoneall/RyhBotPythonSDK2) 构建，并由 [sdkFrame](https://github.com/runoneall/sdkFrame) 提供支持。这是一个异步版本的 SDK，可能在功能和特性上与原库存在一定差异。
+
+ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
+
+## 开发指南
+
+项目的模块化设计允许开发者通过实现符合规范的模块快速扩展功能。模块的结构和接口规范可以参考 [异步模块开发指南](https://github.com/wsu2059q/AsyncRyhBotPythonSDK2/blob/main/%E5%BC%82%E6%AD%A5%E6%A8%A1%E5%9D%97%E5%BC%80%E5%8F%91%E6%8C%87%E5%8D%97.md)。
+
+## 项目结构
+
+```
+ErisPulse/
+├── __init__.py        # 项目初始化
+├── __main__.py        # CLI 接口
+├── envManager.py      # 环境配置管理
+├── errors.py          # 自定义异常
+├── logger.py          # 日志记录
+├── origin.py          # 模块源管理
+├── sdk.py             # SDK 核心
+├── util.py            # 工具函数
+└── modules/           # 功能模块目录
+    └── ...
+```
+
+## 主要模块说明
+
+- **envManager**: 负责管理环境配置和模块信息，使用 SQLite 数据库存储配置
+- **logger**: 提供日志功能，支持不同日志级别
+- **origin**: 管理模块源，添加、删除、更新模块源等方法在此处
+- **util**: 提供工具函数，拓扑排序、异步执行
+- **modules**: 功能模块目录
+
+## 使用说明
+
+1. 安装依赖：`pip install -r requirements.txt`
+2. 查看可用CLI命令：`python -m ErisPulse`
+
+### CLI命令介绍
+
+`ErisPulse` 提供了丰富的 CLI 命令，用于管理模块、源和环境配置。以下是主要命令：
+
+| 命令                          | 功能描述                           |
+|-------------------------------|------------------------------------|
+| `enable <module_name>`        | 启用指定模块                      |
+| `disable <module_name>`       | 禁用指定模块                      |
+| `list [--module <module_name>]` | 列出所有模块或指定模块的详细信息  |
+| `update`                      | 更新模块列表                      |
+| `upgrade [--force]`           | 升级所有模块到最新版本            |
+| `uninstall <module_name>`     | 删除指定模块                      |
+| `install <module_name>`       | 安装指定模块，支持多个模块         |
+
+#### 模块源管理命令
+
+| 命令                          | 功能描述                           |
+|-------------------------------|------------------------------------|
+| `origin add <url>`            | 添加新的模块源                    |
+| `origin list`                 | 列出所有已配置的模块源            |
+| `origin del <url>`            | 删除指定的模块源                  |
+
+
+---
+
+### 模块源
+
+在使用 `ErisPulse` 时，模块源是管理模块的重要组成部分。根据不同的使用场景，模块源分为两种类型：**异步模块源** 和 **同步模块源**。以下是它们的详细说明：
+
+#### 异步模块源
+- URL 1: [https://github.com/wsu2059q/AsyncRBPS-Origin/raw/refs/heads/main/map.json](https://github.com/wsu2059q/AsyncRBPS-Origin/raw/refs/heads/main/map.json)
+- URL 2: [https://sdkframe.anran.xyz/map.json](https://sdkframe.anran.xyz/map.json)
+- 特性：
+  - 支持异步加载模块。
+  - 适用于需要高性能和非阻塞操作的场景。
+  - 推荐用于现代异步框架和应用。
+
+#### 同步模块源
+- URL: [https://runoneall.serv00.net/ryhsdk2/map.json](https://runoneall.serv00.net/ryhsdk2/map.json)
+- 特性：
+  - 传统同步加载模块。
+  - 适用于兼容性要求较高的场景。
+  - 可能会在某些高并发场景下表现不如异步源。
+
+#### 自定义模块源
+用户可以搭建自己的模块源，以下是一个示例格式：
+```json
+{
+  "name": "Custom-Origin",
+  "base": "https://example.com/modules",
+  "modules": {
+    "CustomModule": {
+      "path": "/CustomModule.zip",
+      "version": "1.0.0",
+      "description": "自定义模块示例",
+      "author": "YourName",
+      "dependencies": [],
+      "optional_dependencies": []
+    }
+  }
+}
+```
+
+#### 提供以下命令方便您快速添加源
+```bash
+# 添加异步模块源
+python -m ErisPulse origin add https://github.com/wsu2059q/AsyncRBPS-Origin/raw/refs/heads/main/map.json
+# 添加同步模块源
+python -m ErisPulse origin add https://runoneall.serv00.net/ryhsdk2/map.json
+
+# 添加自定义模块源
+# python -m ErisPulse origin add https://example.com/modules/map.json
+
+# 查看当前配置的模块源
+python -m ErisPulse origin list
+
+# 更新模块列表
+python -m ErisPulse update
+```

erispulse-1.0.0/ErisPulse.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+ErisPulse/__init__.py
+ErisPulse/__main__.py
+ErisPulse/envManager.py
+ErisPulse/errors.py
+ErisPulse/logger.py
+ErisPulse/origin.py
+ErisPulse/sdk.py
+ErisPulse/util.py
+ErisPulse.egg-info/PKG-INFO
+ErisPulse.egg-info/SOURCES.txt
+ErisPulse.egg-info/dependency_links.txt
+ErisPulse.egg-info/requires.txt
+ErisPulse.egg-info/top_level.txt

erispulse-1.0.0/ErisPulse.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

erispulse-1.0.0/ErisPulse.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

erispulse-1.0.0/ErisPulse.egg-info/top_level.txt

@@ -0,0 +1 @@
+ErisPulse