ErisPulse-EmailAdapter 1.0.0__py3-none-any.whl

ErisPulse_EmailAdapter/Core.py

@@ -0,0 +1,503 @@
+import asyncio
+import uuid
+import email
+import smtplib
+import imaplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.application import MIMEApplication
+from typing import Dict, List, Optional, Union, BinaryIO
+from pathlib import Path
+import ssl
+import time
+from dataclasses import dataclass
+
+from ErisPulse import sdk
+from ErisPulse.Core import BaseAdapter
+
+@dataclass
+class EmailAccountConfig:
+    email: str
+    password: str
+    imap_server: Optional[str] = None
+    imap_port: Optional[int] = None
+    smtp_server: Optional[str] = None
+    smtp_port: Optional[int] = None
+    ssl: bool = True
+    timeout: int = 30
+
+class EmailAdapter(BaseAdapter):
+    
+    def __init__(self, sdk):
+        super().__init__()
+        self.sdk = sdk or sdk
+        self.logger = self.sdk.logger
+        self.env = self.sdk.env
+        
+        # 加载配置
+        self.global_config = self._load_global_config()
+        self.accounts: Dict[str, EmailAccountConfig] = self._load_account_configs()
+        
+        # 连接池
+        self.smtp_connections: Dict[str, smtplib.SMTP] = {}
+        self.imap_connections: Dict[str, imaplib.IMAP4_SSL] = {}
+        
+        # 轮询任务
+        self.poll_tasks: Dict[str, asyncio.Task] = {}
+        
+        # 初始化状态
+        self._is_running = False
+
+    def _load_global_config(self) -> Dict:
+        config = self.env.getConfig("EmailAdapter.global", {})
+        
+        if not config:
+            # 设置默认全局配置
+            defaults = {
+                "imap_server": "imap.example.com",
+                "imap_port": 993,
+                "smtp_server": "smtp.example.com",
+                "smtp_port": 465,
+                "ssl": True,
+                "timeout": 30,
+                "poll_interval": 60,
+                "max_retries": 3
+            }
+            self.env.setConfig("EmailAdapter.global", defaults)
+            return defaults
+        return config
+    
+    
+    def _load_account_configs(self) -> Dict[str, EmailAccountConfig]:
+        accounts = {}
+        account_configs = self.env.getConfig("EmailAdapter.accounts", {})
+        
+        if not account_configs:
+            self.logger.warning("未找到任何账号配置，创建默认账号配置")
+            
+            # 设置默认账号配置
+            defaults = {
+                "default": {
+                    "email": "user@example.com",
+                    "password": "password",
+                    "server": {
+                        "imap_server": self.global_config["imap_server"],
+                        "imap_port": self.global_config["imap_port"],
+                        "smtp_server": self.global_config["smtp_server"],
+                        "smtp_port": self.global_config["smtp_port"],
+                        "ssl": self.global_config["ssl"],
+                        "timeout": self.global_config["timeout"]
+                    }
+                }
+            }
+            self.env.setConfig("EmailAdapter.accounts", defaults)
+            account_configs = defaults
+
+        for account_name, config in account_configs.items():
+            # 合并全局配置和账号特定配置
+            merged_config = {
+                "email": config.get("email"),
+                "password": config.get("password"),
+                "imap_server": config.get("server", {}).get("imap_server", self.global_config["imap_server"]),
+                "imap_port": config.get("server", {}).get("imap_port", self.global_config["imap_port"]),
+                "smtp_server": config.get("server", {}).get("smtp_server", self.global_config["smtp_server"]),
+                "smtp_port": config.get("server", {}).get("smtp_port", self.global_config["smtp_port"]),
+                "ssl": config.get("server", {}).get("ssl", self.global_config["ssl"]),
+                "timeout": config.get("server", {}).get("timeout", self.global_config["timeout"]),
+            }
+            
+            accounts[account_name] = EmailAccountConfig(**merged_config)
+        
+        return accounts
+    
+    class Send(BaseAdapter.Send):
+        """邮件发送DSL"""
+        
+        def __init__(self, adapter, target_type=None, target_id=None, _account_id=None):
+            super().__init__(adapter, target_type, target_id, _account_id)
+            self._subject = ""
+            self._html = ""
+            self._text = ""
+            self._attachments = []
+            self._cc = []
+            self._bcc = []
+            self._reply_to = None
+        
+        def Subject(self, subject: str):
+            """设置邮件主题"""
+            self._subject = subject
+            return self
+        
+        def Html(self, html: str):
+            """设置HTML内容并发送邮件"""
+            self._html = html
+            return self._send()
+        
+        def Text(self, text: str):
+            """设置纯文本内容并发送邮件"""
+            self._text = text
+            return self._send()
+        
+        def Attachment(self, file: Union[str, Path, BinaryIO], filename: str = None, 
+                      mime_type: str = "application/octet-stream"):
+            """添加附件"""
+            self._attachments.append((file, filename, mime_type))
+            return self
+        
+        def Cc(self, emails: Union[str, List[str]]):
+            """设置抄送"""
+            if isinstance(emails, str):
+                emails = [emails]
+            self._cc.extend(emails)
+            return self
+        
+        def Bcc(self, emails: Union[str, List[str]]):
+            """设置密送"""
+            if isinstance(emails, str):
+                emails = [emails]
+            self._bcc.extend(emails)
+            return self
+        
+        def ReplyTo(self, email: str):
+            """设置回复地址"""
+            self._reply_to = email
+            return self
+        
+        async def _send(self):
+            """内部发送方法"""
+            if not self._account_id and not self._adapter.accounts:
+                raise ValueError("No email account configured")
+            
+            account_id = self._account_id or next(iter(self._adapter.accounts.keys()))
+            
+            if account_id not in self._adapter.accounts:
+                raise ValueError(f"Account {account_id} not found")
+            
+            account = self._adapter.accounts[account_id]
+            
+            # 构建邮件
+            msg = MIMEMultipart()
+            msg["From"] = account.email
+            msg["To"] = self._target_id if self._target_id else account.email
+            msg["Subject"] = self._subject
+            
+            if self._cc:
+                msg["Cc"] = ", ".join(self._cc)
+            if self._bcc:
+                msg["Bcc"] = ", ".join(self._bcc)
+            if self._reply_to:
+                msg["Reply-To"] = self._reply_to
+            
+            # 添加正文
+            if self._text:
+                msg.attach(MIMEText(self._text, "plain"))
+            if self._html:
+                msg.attach(MIMEText(self._html, "html"))
+            
+            # 添加附件
+            for attachment in self._attachments:
+                file, filename, mime_type = attachment
+                
+                if isinstance(file, (str, Path)):
+                    with open(file, "rb") as f:
+                        part = MIMEApplication(f.read(), Name=filename or Path(file).name)
+                else:
+                    part = MIMEApplication(file.read(), Name=filename)
+                
+                part["Content-Disposition"] = f'attachment; filename="{filename}"'
+                msg.attach(part)
+            
+            # 发送邮件
+            try:
+                await self._adapter._send_email(account_id, msg)
+                return {
+                    "status": "ok",
+                    "retcode": 0,
+                    "data": {"message": "Email sent successfully"},
+                    "message": "Email sent successfully",
+                    "message_id": uuid.uuid4().hex,
+                }
+            except Exception as e:
+                self._adapter.logger.error(f"Failed to send email: {str(e)}")
+                return {
+                    "status": "failed",
+                    "retcode": 34000,
+                    "data": None,
+                    "message": str(e),
+                    "message_id": "",
+                }
+
+    async def _send_email(self, account_id: str, msg: MIMEMultipart):
+        """实际发送邮件"""
+        account = self.accounts[account_id]
+        
+        try:
+            if account_id not in self.smtp_connections:
+                await self._connect_smtp(account_id)
+            
+            smtp = self.smtp_connections[account_id]
+            smtp.send_message(msg)
+        except Exception as e:
+            self.logger.error(f"SMTP error: {str(e)}")
+            # 尝试重新连接
+            await self._connect_smtp(account_id)
+            smtp = self.smtp_connections[account_id]
+            smtp.send_message(msg)
+    
+    async def _connect_smtp(self, account_id: str):
+        """连接SMTP服务器"""
+        account = self.accounts[account_id]
+        
+        if account_id in self.smtp_connections:
+            try:
+                self.smtp_connections[account_id].quit()
+            except:
+                pass
+        
+        context = ssl.create_default_context()
+        
+        if account.ssl:
+            smtp = smtplib.SMTP_SSL(
+                host=account.smtp_server,
+                port=account.smtp_port,
+                timeout=account.timeout,
+                context=context
+            )
+        else:
+            smtp = smtplib.SMTP(
+                host=account.smtp_server,
+                port=account.smtp_port,
+                timeout=account.timeout
+            )
+            if account.ssl:
+                smtp.starttls(context=context)
+        
+        smtp.login(account.email, account.password)
+        self.smtp_connections[account_id] = smtp
+    
+    async def _connect_imap(self, account_id: str):
+        """连接IMAP服务器"""
+        account = self.accounts[account_id]
+        
+        if account_id in self.imap_connections:
+            try:
+                self.imap_connections[account_id].logout()
+            except:
+                pass
+        
+        context = ssl.create_default_context()
+        
+        imap = imaplib.IMAP4_SSL(
+            host=account.imap_server,
+            port=account.imap_port,
+            ssl_context=context
+        )
+        
+        imap.login(account.email, account.password)
+        imap.select("INBOX")
+        self.imap_connections[account_id] = imap
+    
+    async def _poll_emails(self, account_id: str):
+        """轮询邮箱获取新邮件"""
+        poll_interval = self.global_config.get("poll_interval", 60)
+        max_retries = self.global_config.get("max_retries", 3)
+        
+        while self._is_running:
+            try:
+                if account_id not in self.imap_connections:
+                    await self._connect_imap(account_id)
+                
+                imap = self.imap_connections[account_id]
+                imap.noop()  # 保持连接活跃
+                
+                # 搜索未读邮件
+                status, messages = imap.search(None, "UNSEEN")
+                if status == "OK" and messages[0]:
+                    for num in messages[0].split():
+                        status, data = imap.fetch(num, "(RFC822)")
+                        if status == "OK":
+                            raw_email = data[0][1]
+                            email_message = email.message_from_bytes(raw_email)
+                            
+                            # 转换为标准事件
+                            event = self._convert_email_to_event(email_message, account_id)
+                            await self.emit("email", event)
+                            await sdk.adapter.emit(event)
+
+                await asyncio.sleep(poll_interval)
+            except Exception as e:
+                self.logger.error(f"Polling error for {account_id}: {str(e)}")
+                retries = 0
+                while retries < max_retries:
+                    try:
+                        await self._connect_imap(account_id)
+                        break
+                    except Exception as e:
+                        retries += 1
+                        if retries >= max_retries:
+                            self.logger.error(f"Failed to reconnect after {max_retries} attempts")
+                            raise
+                        await asyncio.sleep(5)
+    
+    def _convert_email_to_event(self, email_message: email.message.Message, account_id: str) -> Dict:
+        """将邮件转换为标准事件格式"""
+        # 解析邮件内容
+        def decode_header(header):
+            from email.header import decode_header
+            decoded = decode_header(header)
+            parts = []
+            for part, encoding in decoded:
+                if isinstance(part, bytes):
+                    try:
+                        part = part.decode(encoding or 'utf-8')
+                    except:
+                        part = part.decode('utf-8', errors='replace')
+                parts.append(part)
+            return ''.join(parts)
+
+        subject = decode_header(email_message.get("Subject", ""))
+        from_ = decode_header(email_message.get("From", ""))
+        to = decode_header(email_message.get("To", ""))
+        date = email_message.get("Date", "")
+        
+        # 解析正文
+        text_content = ""
+        html_content = ""
+        attachments = []
+        
+        for part in email_message.walk():
+            content_type = part.get_content_type()
+            content_disposition = str(part.get("Content-Disposition"))
+            
+            if "attachment" in content_disposition:
+                # 处理附件
+                filename = part.get_filename()
+                if filename:
+                    attachments.append({
+                        "filename": filename,
+                        "content_type": content_type,
+                        "size": len(part.get_payload(decode=True)),
+                        "data": part.get_payload(decode=True)
+                    })
+            elif content_type == "text/plain":
+                # 纯文本内容
+                payload = part.get_payload(decode=True)
+                try:
+                    text_content = payload.decode('utf-8')
+                except UnicodeDecodeError:
+                    try:
+                        text_content = payload.decode('gbk')
+                    except UnicodeDecodeError:
+                        text_content = payload.decode('utf-8', errors='replace')
+            elif content_type == "text/html":
+                # HTML内容
+                payload = part.get_payload(decode=True)
+                try:
+                    html_content = payload.decode('utf-8')
+                except UnicodeDecodeError:
+                    try:
+                        html_content = payload.decode('gbk')
+                    except UnicodeDecodeError:
+                        html_content = payload.decode('utf-8', errors='replace')
+        
+        # 构建标准事件
+        return {
+            "id": email_message.get("Message-ID", ""),
+            "time": self._parse_email_date(date),
+            "type": "message",
+            "detail_type": "private",  # 邮件默认为私聊
+            "platform": "email",
+            "self": {
+                "platform": "email",
+                "user_id": account_id
+            },
+            "message": [
+                {
+                    "type": "text",
+                    "data": {
+                        "text": f"Subject: {subject}\nFrom: {from_}\n\n{text_content}"
+                    }
+                }
+            ],
+            "alt_message": f"邮件: {subject}",
+            "user_id": from_,
+            "email_raw": {
+                "subject": subject,
+                "from": from_,
+                "to": to,
+                "date": date,
+                "text_content": text_content,
+                "html_content": html_content,
+                "attachments": [att["filename"] for att in attachments]
+            },
+            "attachments": attachments
+        }
+    
+    def _parse_email_date(self, date_str: str) -> int:
+        """解析邮件日期为时间戳"""
+        from email.utils import parsedate_to_datetime
+        try:
+            dt = parsedate_to_datetime(date_str)
+            return int(dt.timestamp())
+        except:
+            return int(time.time())
+    
+    async def call_api(self, endpoint: str, **params):
+        """实现BaseAdapter要求的call_api方法"""
+        if endpoint == "send":
+            return await self.Send(self).Text(params.get("content", "")).send()
+        elif endpoint == "send_html":
+            return await self.Send(self).Html(params.get("html", "")).send()
+        else:
+            return {
+                "status": "failed",
+                "retcode": 10002,
+                "data": None,
+                "message": f"Unsupported endpoint: {endpoint}",
+                "message_id": ""
+            }
+    
+    async def start(self):
+        """启动适配器"""
+        if not self.accounts:
+            self.logger.warning("No email accounts configured")
+            return
+        
+        self._is_running = True
+        
+        # 连接所有SMTP服务器
+        for account_id in self.accounts:
+            try:
+                await self._connect_smtp(account_id)
+            except Exception as e:
+                self.logger.error(f"Failed to connect SMTP for {account_id}: {str(e)}")
+        
+        # 启动轮询任务
+        for account_id in self.accounts:
+            if self.accounts[account_id].imap_server:  # 只有配置了IMAP的账号才轮询
+                self.poll_tasks[account_id] = asyncio.create_task(self._poll_emails(account_id))
+    
+    async def shutdown(self):
+        """关闭适配器"""
+        self._is_running = False
+        
+        # 取消所有轮询任务
+        for task in self.poll_tasks.values():
+            task.cancel()
+        self.poll_tasks.clear()
+        
+        # 关闭所有SMTP连接
+        for account_id, smtp in self.smtp_connections.items():
+            try:
+                smtp.quit()
+            except:
+                pass
+        self.smtp_connections.clear()
+        
+        # 关闭所有IMAP连接
+        for account_id, imap in self.imap_connections.items():
+            try:
+                imap.logout()
+            except:
+                pass
+        self.imap_connections.clear()

ErisPulse_EmailAdapter/__init__.py

@@ -0,0 +1 @@
+from .Core import EmailAdapter

erispulse_emailadapter-1.0.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: ErisPulse-EmailAdapter
+Version: 1.0.0
+Summary: ErisPulse邮箱适配器，支持多账号管理、HTML内容和附件发送
+Author-email: wsu2059q <wsu2059@qq.com>
+Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-EmailAdapter
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ErisPulse 邮箱适配器
+
+一个为 ErisPulse 框架设计的强大邮箱适配器，支持在 ErisPulse 生态系统中以事件形式收发电子邮件。
+
+## 功能特性
+
+- **多账户支持**：可配置多个邮箱账户，每个账户可设置独立的SMTP/IMAP参数
+- **全局配置**：可定义全局SMTP和IMAP设置，所有账户均可继承
+- **邮件轮询**：自动检查邮箱账户中的新邮件(未读邮件)，并将其转换为标准ErisPulse事件
+- **DSL发送**：使用标准ErisPulse `Send` DSL轻松发送邮件
+- **附件支持**：支持发送和接收邮件附件
+- **HTML与纯文本**：同时支持HTML和纯文本邮件内容
+
+## 安装
+
+像安装其他ErisPulse模块或适配器一样安装本适配器：
+
+```bash
+epsdk install Email
+```
+
+如果与ErisPulse安装在同一个Python环境中，它将被自动发现。
+
+## 配置
+
+首次运行后，适配器会在您的`config.toml`文件中生成默认配置块。您需要用真实的邮箱账户信息更新它。
+
+### 配置示例
+
+```toml
+[EmailAdapter.global]
+imap_server = "imap.example.com"  # 全局IMAP服务器
+imap_port = 993                   # IMAP端口
+smtp_server = "smtp.example.com"  # 全局SMTP服务器
+smtp_port = 465                   # SMTP端口
+ssl = true                        # 使用SSL/TLS加密
+timeout = 30                      # 连接超时时间(秒)
+poll_interval = 10                # 邮件轮询间隔(秒)
+max_retries = 3                   # 失败连接的最大重试次数
+
+[EmailAdapter.accounts."support@example.com"]
+email = "support@example.com"     # 账户邮箱地址
+password = "yourpassword"         # 账户密码
+
+[EmailAdapter.accounts."user@example.com"]
+email = "user@example.com"
+password = "anotherpassword"
+```
+
+## 使用方法
+
+### 发送邮件
+
+使用标准ErisPulse `Send` DSL发送邮件。接收者应为目标邮箱地址。
+
+```python
+from ErisPulse import sdk
+
+# 从默认账户发送
+await sdk.adapter.mail.Send.To("recipient@example.com").Text("来自ErisPulse的问候！")
+
+# 从特定账户发送带主题的邮件
+await sdk.adapter.mail.Send.Using("support@example.com").To("client@company.com") \
+    .Subject("重要更新"). \
+    .Attachment("document.pdf").
+    Text("请查看附件中的文档。") \
+
+
+# 发送HTML邮件
+html_content = """
+<h1>欢迎！</h1>
+<p>感谢使用我们的服务。</p>
+"""
+await sdk.adapter.mail.Send.To("user@example.com") \
+    .Subject("HTML邮件").Html(html_content)
+```
+
+### 接收邮件
+
+收到的邮件会自动转换为标准`message`事件。您可以像监听其他消息一样监听它们。
+
+```python
+from ErisPulse import sdk, adapter
+
+@adapter.on("message")
+async def handle_email_messages(data: dict):
+    # 检查消息是否来自邮箱适配器
+    if data.get("platform") == "mail":
+        sender = data.get("user_id")
+        subject = data["email_raw"]["subject"]
+        content = data["email_raw"]["text_content"]
+        
+        print(f"新邮件来自: {sender}")
+        print(f"主题: {subject}")
+        print(f"内容:\n{content}")
+        
+        # 检查附件
+        if data.get("attachments"):
+            print(f"附件: {[a['filename'] for a in data['attachments']]}")
+
+        # 自动回复示例
+        await sdk.adapter.mail.Send.To(sender) \
+            .Subject(f"回复: {subject}") \
+            .Text("已收到您的邮件，我们将尽快回复。")
+```

erispulse_emailadapter-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+ErisPulse_EmailAdapter/Core.py,sha256=GBnIQ5OeIcymwawaKxEQXsSt_sZc1etd936NGjB1RA4,18711
+ErisPulse_EmailAdapter/__init__.py,sha256=RfKxOCWydbD2lmBuN3j2XG7rY51NMQoRbgODqDzxfTc,30
+erispulse_emailadapter-1.0.0.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
+erispulse_emailadapter-1.0.0.dist-info/METADATA,sha256=pBO-3R1OcPY8N-bcw5qDQ_SAIv_SkwFsb5L8wKp8Di0,3766
+erispulse_emailadapter-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+erispulse_emailadapter-1.0.0.dist-info/entry_points.txt,sha256=vwhGR7PtKqE6mNgE8P28j1KSR-IuKAvn4rucPzoG1eM,87
+erispulse_emailadapter-1.0.0.dist-info/top_level.txt,sha256=zJUhl2prl4w--ckOa4rmO8okRElRvCvmOMK6WjYkqFg,23
+erispulse_emailadapter-1.0.0.dist-info/RECORD,,

erispulse_emailadapter-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

erispulse_emailadapter-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[erispulse.adapter]
+email = EmailAdapter:EmailAdapter
+mail = EmailAdapter:EmailAdapter

erispulse_emailadapter-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,31 @@
+MIT License
+
+Copyright (c) 2025 ErisPulse
+
+Portions of this software are based on https://github.com/runoneall/sdkFrame.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+This SDK's core adapter standardization layer strictly follows OneBot12 specifications (https://12.onebot.dev/) for:
+- Event data normalization
+- API request/response formats
+- Message segment definitions
+- Metadata definitions
+
+This ensures consistent behavior and interoperability across all adapter implementations.

erispulse_emailadapter-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ErisPulse_EmailAdapter