python-library-lagrange-adapter 0.1.0__py3-none-any.whl

lagrange_adapter/__init__.py

@@ -0,0 +1,4 @@
+from lagrange_adapter.adapter import Adapter
+from lagrange_adapter.listener import Listener
+
+__all__ = ["Adapter", "Listener"]

lagrange_adapter/adapter.py

@@ -0,0 +1,128 @@
+from collections.abc import Awaitable, Callable
+
+from onebot_protocol import MessagePayload
+
+from lagrange_adapter.bot import Bot
+from lagrange_adapter.listener import (
+    Listener,
+    emit_disconnect,
+    emit_error,
+    emit_message,
+    emit_void,
+)
+from lagrange_adapter.models import BotMessage
+from lagrange_adapter.protocol_adapt import bot_to_onebot, onebot_to_bot
+
+MessageCallback = Callable[[MessagePayload], Awaitable[None]]
+
+
+class Adapter:
+    """Lagrange 反向 WebSocket 对外门面：入站转统一载荷，出站从载荷发回 CQ 段。
+
+    群聊默认仅在 @ 机器人时上报；过滤规则在包内完成。
+    """
+
+    def __init__(
+        self,
+        port: int = 6199,
+        *,
+        listeners: list[Listener] | None = None,
+    ) -> None:
+        """创建适配器并绑定内部反向 WS 服务。
+
+        Args:
+            port: 本机监听端口，供 Lagrange 连接
+            listeners: 构造期注册的多组事件监听器
+        """
+        self._callbacks: list[MessageCallback] = []
+        self._listeners: list[Listener] = list(listeners or [])
+        self._bot = Bot(port=port)
+        self._bot.on_message(self._on_bot_message)
+        self._bot.on_connect(self._on_connect)
+        self._bot.on_ready(self._on_ready)
+        self._bot.on_disconnect(self._on_disconnect)
+        self._bot.on_error(self._on_error)
+
+    def register(self, callback: MessageCallback) -> None:
+        """登记一条消息回调，与监听器中的消息槽位一并触发。
+
+        Args:
+            callback: 异步处理入站统一消息载荷
+        """
+        self._callbacks.append(callback)
+
+    def on_message(
+        self, callback: MessageCallback | None = None
+    ) -> MessageCallback | Callable[[MessageCallback], MessageCallback]:
+        """登记消息回调；无参调用时返回装饰器。
+
+        Args:
+            callback: 直接传入的异步处理函数；省略时用于装饰器写法
+
+        Returns:
+            装饰器模式下返回原函数；直接传入时返回同一回调
+        """
+        if callback is not None:
+            self.register(callback)
+            return callback
+
+        def decorator(fn: MessageCallback) -> MessageCallback:
+            self.register(fn)
+            return fn
+
+        return decorator
+
+    async def send(self, payload: MessagePayload) -> None:
+        """按统一载荷向当前会话发送消息。
+
+        Args:
+            payload: 目标会话与消息段列表
+        """
+        await self._bot.send(onebot_to_bot(payload))
+
+    async def _on_bot_message(self, msg: BotMessage) -> None:
+        payload = bot_to_onebot(msg)
+        if payload is None:
+            return
+        await emit_message(self._listeners, payload)
+        for callback in self._callbacks:
+            try:
+                await callback(payload)
+            except Exception:
+                pass
+
+    async def _on_connect(self) -> None:
+        await emit_void(self._listeners, "on_connect")
+
+    async def _on_ready(self) -> None:
+        await emit_void(self._listeners, "on_ready")
+
+    async def _on_disconnect(self, reason: str) -> None:
+        await emit_disconnect(self._listeners, reason)
+
+    async def _on_error(self, exc: BaseException) -> None:
+        await emit_error(self._listeners, exc)
+
+    async def start(self) -> None:
+        """在后台启动反向 WebSocket 服务，不阻塞当前协程。
+
+        与 stop 配对；长期运行请用 run。
+        """
+        await emit_void(self._listeners, "on_start")
+        await self._bot.start()
+
+    async def stop(self) -> None:
+        """停止服务并结束事件循环；会触发监听器的 on_stop。"""
+        await self._bot.stop()
+        await emit_void(self._listeners, "on_stop")
+
+    async def run(self) -> None:
+        """启动并阻塞直到停止；适合 asyncio.run(adapter.run())。
+
+        Ctrl+C 或任务取消时会断开连接并触发 on_stop。
+        """
+        await emit_void(self._listeners, "on_start")
+        try:
+            await self._bot.run()
+        finally:
+            await emit_void(self._listeners, "on_stop")

lagrange_adapter/bot.py

@@ -0,0 +1,215 @@
+from aiocqhttp import CQHttp, Event
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+
+import asyncio
+from pydantic import BaseModel, Field
+
+from lagrange_adapter.models import BotMessage, MessageType
+
+VoidCallback = Callable[[], Awaitable[None]]
+DisconnectCallback = Callable[[str], Awaitable[None]]
+ErrorCallback = Callable[[BaseException], Awaitable[None]]
+
+
+class Bot(BaseModel):
+    """Lagrange 反向 WebSocket 服务：接收 CQ 事件并回发消息。
+
+    构造入参见各字段的 description；包外请优先使用 Adapter。
+    """
+
+    port: int = Field(default=6199, description="本机监听端口，供 Lagrange 连接")
+
+    def model_post_init(self, ctx: object) -> None:
+        """初始化运行期状态与事件槽位。"""
+        self._stop_event = asyncio.Event()
+
+        self._bot = None
+        self._login_info = None
+        self._bot_name: str = None
+        self._bot_id: str = None
+        self._running = False
+        self._on_message: Callable[[BotMessage], Awaitable[None]] | None = None
+        self._on_connect: VoidCallback | None = None
+        self._on_ready: VoidCallback | None = None
+        self._on_disconnect: DisconnectCallback | None = None
+        self._on_error: ErrorCallback | None = None
+        self._ws_task: asyncio.Task[None] | None = None
+
+    def on_message(self, callback: Callable[[BotMessage], Awaitable[None]]) -> None:
+        """登记入站聊天事件回调。
+
+        Args:
+            callback: 异步处理包内机器人消息
+        """
+        self._on_message = callback
+
+    def on_connect(self, callback: VoidCallback) -> None:
+        """登记 WebSocket 已连接回调。"""
+        self._on_connect = callback
+
+    def on_ready(self, callback: VoidCallback) -> None:
+        """登记登录信息就绪回调。"""
+        self._on_ready = callback
+
+    def on_disconnect(self, callback: DisconnectCallback) -> None:
+        """登记连接断开回调。
+
+        Args:
+            callback: 异步处理断开原因短句
+        """
+        self._on_disconnect = callback
+
+    def on_error(self, callback: ErrorCallback) -> None:
+        """登记运行期错误回调。
+
+        Args:
+            callback: 异步处理异常对象
+        """
+        self._on_error = callback
+
+    async def _emit_connect(self) -> None:
+        if self._on_connect is None:
+            return
+        try:
+            await self._on_connect()
+        except Exception:
+            pass
+
+    async def _emit_ready(self) -> None:
+        if self._on_ready is None:
+            return
+        try:
+            await self._on_ready()
+        except Exception:
+            pass
+
+    async def _emit_disconnect(self, reason: str) -> None:
+        if self._on_disconnect is None:
+            return
+        try:
+            await self._on_disconnect(reason)
+        except Exception:
+            pass
+
+    async def _emit_error(self, exc: BaseException) -> None:
+        if self._on_error is None:
+            return
+        try:
+            await self._on_error(exc)
+        except Exception:
+            pass
+
+    async def _get_login_info(self):
+        try:
+            self._login_info = await self._bot.get_login_info()
+            self._bot_name = self._login_info["nickname"]
+            self._bot_id = str(self._login_info["user_id"])
+        except Exception:
+            pass
+
+    async def _handle_ws(self):
+        self._bot = CQHttp(api_root='')
+
+        @self._bot.on_websocket_connection
+        async def _(_):
+            await self._emit_connect()
+            await self._get_login_info()
+            await self._emit_ready()
+
+        @self._bot.on_message
+        async def _(event: Event, **kwargs):
+            if self._login_info is None:
+                await self._get_login_info()
+
+            user_name = str(event.user_id)
+            session_id = str(event.group_id) if event.message_type == 'group' else user_name
+            message_type = MessageType.GROUP if event.message_type == 'group' else MessageType.PRIVATE
+            data_list = event.message
+            message_id = str(event.message_id)
+
+            message = BotMessage(
+                session_id=session_id,
+                data_list=data_list,
+                bot_id=self._bot_id,
+                message_type=message_type,
+                user_name=user_name,
+                message_id=message_id,
+                bot_name=self._bot_name,
+            )
+
+            if self._on_message is not None:
+                try:
+                    await self._on_message(message)
+                except Exception:
+                    pass
+
+        @self._bot.on('error')
+        async def _(event: Event):
+            await self._emit_error(RuntimeError(str(event)))
+
+        try:
+            await self._bot.run_task(
+                host='0.0.0.0',
+                port=self.port,
+                shutdown_trigger=self._stop_event.wait,
+            )
+        finally:
+            await self._emit_disconnect("stopped")
+
+    async def start(self) -> None:
+        """在后台启动反向 WebSocket 服务，不阻塞当前协程。"""
+        if self._running:
+            return
+        self._running = True
+        self._stop_event.clear()
+        self._ws_task = asyncio.create_task(self._handle_ws())
+
+    async def send(self, message: BotMessage) -> None:
+        """向群或好友发送 CQ 段列表。
+
+        Args:
+            message: 含会话类型与 data_list 的包内消息
+        """
+        data_list = [
+            {"type": segment["type"], "data": segment.get("data", {})}
+            for segment in message.data_list
+        ]
+
+        try:
+            sid = int(message.session_id)
+            if message.message_type == MessageType.GROUP:
+                await self._bot.send_msg(
+                    message_type="group",
+                    group_id=sid,
+                    message=data_list,
+                )
+            else:
+                await self._bot.send_msg(
+                    message_type="private",
+                    user_id=sid,
+                    message=data_list,
+                )
+        except Exception:
+            pass
+
+    async def stop(self) -> None:
+        """触发关闭并结束常驻运行。"""
+        if not self._running:
+            self._stop_event.set()
+            return
+        self._running = False
+        self._stop_event.set()
+        if self._ws_task is not None and self._ws_task is not asyncio.current_task():
+            self._ws_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._ws_task
+        self._ws_task = None
+
+    async def run(self) -> None:
+        """启动服务并阻塞；Ctrl+C 或任务取消时收尾退出。"""
+        await self.start()
+        try:
+            await self._stop_event.wait()
+        finally:
+            await self.stop()

lagrange_adapter/listener.py

@@ -0,0 +1,97 @@
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+
+from onebot_protocol import MessagePayload
+
+MessageCallback = Callable[[MessagePayload], Awaitable[None]]
+VoidCallback = Callable[[], Awaitable[None]]
+DisconnectCallback = Callable[[str], Awaitable[None]]
+ErrorCallback = Callable[[BaseException], Awaitable[None]]
+
+
+@dataclass
+class Listener:
+    """按事件名挂接异步回调；未赋值的槽位不参与派发。
+
+    构造适配器时传入列表，与运行期登记的消息回调可同时存在。
+    """
+
+    on_message: MessageCallback | None = None
+    """收到已转为统一消息载荷的入站聊天消息。"""
+    on_start: VoidCallback | None = None
+    """适配器开始监听或进入常驻运行。"""
+    on_stop: VoidCallback | None = None
+    """适配器停止监听或常驻运行结束。"""
+    on_ready: VoidCallback | None = None
+    """平台侧会话就绪，可稳定收发。"""
+    on_connect: VoidCallback | None = None
+    """底层传输已连通，未必已完成鉴权。"""
+    on_disconnect: DisconnectCallback | None = None
+    """传输断开；参数为平台给出的原因短句。"""
+    on_error: ErrorCallback | None = None
+    """连接或运行期未捕获的异常。"""
+
+
+async def emit_void(listeners: list[Listener], name: str) -> None:
+    """对监听器列表派发无参生命周期类回调。
+
+    Args:
+        listeners: 适配器持有的监听器实例
+        name: 监听器上对应的无参槽位名
+    """
+    for listener in listeners:
+        cb = getattr(listener, name, None)
+        if cb is None:
+            continue
+        try:
+            await cb()
+        except Exception:
+            pass
+
+
+async def emit_disconnect(listeners: list[Listener], reason: str) -> None:
+    """对监听器列表派发断开回调。
+
+    Args:
+        listeners: 适配器持有的监听器实例
+        reason: 断开原因，供日志或重连策略使用
+    """
+    for listener in listeners:
+        if listener.on_disconnect is None:
+            continue
+        try:
+            await listener.on_disconnect(reason)
+        except Exception:
+            pass
+
+
+async def emit_error(listeners: list[Listener], exc: BaseException) -> None:
+    """对监听器列表派发错误回调。
+
+    Args:
+        listeners: 适配器持有的监听器实例
+        exc: 本次错误对象
+    """
+    for listener in listeners:
+        if listener.on_error is None:
+            continue
+        try:
+            await listener.on_error(exc)
+        except Exception:
+            pass
+
+
+async def emit_message(listeners: list[Listener], payload: MessagePayload) -> None:
+    """对监听器列表派发消息回调。
+
+    Args:
+        listeners: 适配器持有的监听器实例
+        payload: 已转换为对外统一格式的入站消息
+    """
+    for listener in listeners:
+        if listener.on_message is None:
+            continue
+        try:
+            await listener.on_message(payload)
+        except Exception:
+            pass

lagrange_adapter/models.py

@@ -0,0 +1,165 @@
+from enum import StrEnum
+from typing import Annotated, Literal, Union
+
+from pydantic import BaseModel, Field
+
+
+class MessageType(StrEnum):
+    """会话类型：私聊或群聊。"""
+
+    PRIVATE = "private"
+    GROUP = "group"
+
+
+class BaseSegment(BaseModel):
+    """CQ 消息段通用壳：类型名与原始数据字典。"""
+
+    type: str = Field(description="段类型，如 text、at、image")
+    data: dict = Field(description="协议原始字段字典")
+
+
+class AtSegment(BaseSegment):
+    """@ 成员段。"""
+
+    type: Literal["at"] = "at"
+    qq: str | None = None
+    name: str | None = None
+
+    def model_post_init(self, ctx) -> None:
+        self.qq = self.data["qq"]
+        self.name = self.data["name"].lstrip("@").strip()
+
+
+class FaceSegment(BaseSegment):
+    """QQ 表情段。"""
+
+    type: Literal["face"] = "face"
+    id: str | None = None
+    large: str | None = None
+
+    def model_post_init(self, ctx) -> None:
+        self.id = self.data["id"]
+        self.large = self.data["large"]
+
+
+class TextSegment(BaseSegment):
+    """纯文本段。"""
+
+    type: Literal["text"] = "text"
+    text: str | None = None
+
+    def model_post_init(self, ctx) -> None:
+        self.text = self.data["text"]
+
+
+class ReplySegment(BaseSegment):
+    """引用回复段。"""
+
+    type: Literal["reply"] = "reply"
+    id: str | None = None
+
+    def model_post_init(self, ctx) -> None:
+        self.id = self.data["id"]
+
+
+class MfaceSegment(BaseSegment):
+    """商城表情段。"""
+
+    type: Literal["mface"] = "mface"
+    url: str | None = None
+    emoji_package_id: str | None = None
+    emoji_id: str | None = None
+    key: str | None = None
+    summary: str | None = None
+
+
+class LocationSegment(BaseSegment):
+    """位置段。"""
+
+    type: Literal["location"] = "location"
+    lat: float | None = None
+    lon: float | None = None
+    title: str | None = None
+    content: str | None = None
+
+
+class JsonSegment(BaseSegment):
+    """JSON 卡片段。"""
+
+    type: Literal["json"] = "json"
+
+
+class ImageSegment(BaseSegment):
+    """图片段。"""
+
+    type: Literal["image"] = "image"
+    file: str | None = None
+    filename: str | None = None
+    url: str | None = None
+    summary: str | None = None
+    subType: str | None = None
+
+
+class ForwardSegment(BaseSegment):
+    """合并转发段。"""
+
+    type: Literal["forward"] = "forward"
+    id: str | None = None
+
+
+class VideoSegment(BaseSegment):
+    """视频段。"""
+
+    type: Literal["video"] = "video"
+    file: str | None = None
+    url: str | None = None
+
+    def model_post_init(self, ctx) -> None:
+        self.file = self.data["file"]
+        self.url = self.data["url"]
+
+
+Segment = Annotated[
+    Union[
+        TextSegment,
+        ImageSegment,
+        FaceSegment,
+        AtSegment,
+        ForwardSegment,
+        ReplySegment,
+        JsonSegment,
+        VideoSegment,
+        MfaceSegment,
+        LocationSegment,
+    ],
+    Field(discriminator="type"),
+]
+
+
+class BotMessage(BaseModel):
+    """包内入站/出站消息：CQ 段列表与会话上下文。"""
+
+    message_id: str = Field(description="平台分配的消息编号")
+    data_list: list[dict] = Field(description="CQ 协议段列表，每项含 type 与 data")
+    message_type: MessageType = Field(description="私聊或群聊")
+    bot_id: str = Field(description="当前机器人 QQ 号")
+    bot_name: str | None = Field(default=None, description="机器人昵称，用于解析 @")
+    session_id: str = Field(description="群号或好友号，用作发送目标")
+    user_name: str = Field(description="发送方 QQ 号")
+
+
+__all__ = [
+    "BotMessage",
+    "BaseSegment",
+    "TextSegment",
+    "ImageSegment",
+    "FaceSegment",
+    "AtSegment",
+    "ForwardSegment",
+    "ReplySegment",
+    "JsonSegment",
+    "VideoSegment",
+    "MfaceSegment",
+    "LocationSegment",
+    "Segment",
+]

lagrange_adapter/protocol_adapt.py

@@ -0,0 +1,194 @@
+from typing import List, Union, Optional
+from lagrange_adapter.models import (
+    BaseSegment,
+    TextSegment,
+    ImageSegment,
+    FaceSegment,
+    AtSegment,
+    ForwardSegment,
+    ReplySegment,
+    JsonSegment,
+    VideoSegment,
+    MfaceSegment,
+    LocationSegment,
+    BotMessage,
+    MessageType,
+)
+import onebot_protocol
+from onebot_protocol import MessagePayload
+
+SEGMENT_MAP = {
+    "text": TextSegment,
+    "image": ImageSegment,
+    "face": FaceSegment,
+    "at": AtSegment,
+    "forward": ForwardSegment,
+    "reply": ReplySegment,
+    "json": JsonSegment,
+    "video": VideoSegment,
+    "mface": MfaceSegment,
+    "location": LocationSegment,
+}
+
+USER_MAP: dict[str, str] = {}
+
+MENTION_ALL_NAME = "全体成员"
+
+
+def data_to_segments(data_list: list[dict], bot_name: str, bot_id: str) -> list[BaseSegment]:
+    """把原始段字典列表转为强类型段，并拆分正文里的 @ 机器人。
+
+    Args:
+        data_list: 事件中的 CQ 段列表
+        bot_name: 机器人昵称，用于匹配 @
+        bot_id: 机器人 QQ 号
+
+    Returns:
+        过滤无效项并展开 @ 后的段列表
+    """
+    segments = [_cast_segment(x) for x in data_list]
+    segments = [x for x in segments if x]
+
+    segments = [
+        (_extract_mention_robot(x, bot_name, bot_id) if isinstance(x, TextSegment) else [x])
+        for x in segments
+    ]
+    segments = [x for data in segments for x in data]
+
+    return segments
+
+
+def onebot_to_bot(payload: MessagePayload) -> BotMessage:
+    """把对外统一载荷转成 CQ 段列表供 aiocqhttp 发送。
+
+    Args:
+        payload: 会话、消息段与机器人标识
+
+    Returns:
+        含 data_list 的包内机器人消息
+    """
+    data_list = []
+    for message in payload.messages:
+        if isinstance(message, onebot_protocol.TextMessageSegment):
+            message = TextSegment(data={"text": message.data.text})
+        elif isinstance(message, onebot_protocol.MentionMessageSegment):
+            name = USER_MAP.get(message.data.user_id)
+            if not name:
+                continue
+            message = AtSegment(data={"qq": message.data.user_id, "name": name})
+        data_list.append(message.model_dump())
+
+    msg = BotMessage(
+        message_id=payload.message_id,
+        data_list=data_list,
+        message_type=MessageType(payload.source_type),
+        bot_id=payload.bot_id,
+        session_id=payload.session_id,
+        user_name=payload.user_id or "",
+    )
+
+    if msg.message_type == MessageType.GROUP:
+        if msg.user_name:
+            msg.data_list = [
+                AtSegment(data={"qq": msg.user_name, "name": USER_MAP.get(msg.user_name, "")}).model_dump(),
+                TextSegment(data={"text": " "}).model_dump(),
+            ] + msg.data_list
+
+    return msg
+
+
+def bot_to_onebot(msg: BotMessage) -> Optional[MessagePayload]:
+    """把入站 CQ 消息转为对外统一载荷；群聊未 @ 机器人时返回空。
+
+    Args:
+        msg: 事件解析后的包内消息
+
+    Returns:
+        可上报的统一载荷；无需上报时为 None
+    """
+    global USER_MAP
+
+    segments = data_to_segments(msg.data_list, msg.bot_name, msg.bot_id)
+
+    if not _should_broadcast(msg, segments):
+        return None
+
+    for segment in segments:
+        if isinstance(segment, AtSegment) and segment.qq == msg.bot_id:
+            segments.remove(segment)
+
+    messages = []
+    for segment in segments:
+        if isinstance(segment, TextSegment):
+            text = segment.text.strip()
+            if not text:
+                continue
+            message = onebot_protocol.TextMessageSegment(data={"text": text})
+        elif isinstance(segment, AtSegment):
+            if segment.name == MENTION_ALL_NAME:
+                message = onebot_protocol.MentionAllMessageSegment()
+            else:
+                message = onebot_protocol.MentionMessageSegment(data={"user_id": segment.qq})
+            USER_MAP[segment.qq] = segment.name
+        else:
+            continue
+        messages.append(message)
+
+    if not messages:
+        return None
+
+    return MessagePayload(
+        message_id=msg.message_id,
+        source_type=msg.message_type.value,
+        bot_id=msg.bot_id,
+        session_id=msg.session_id,
+        user_id=msg.user_name,
+        messages=messages,
+    )
+
+
+def _should_broadcast(msg: BotMessage, segments: list[BaseSegment]) -> bool:
+    """群聊仅在 @ 到机器人时向上层上报。"""
+    if msg.message_type == MessageType.GROUP:
+        for segment in segments:
+            if isinstance(segment, AtSegment) and segment.qq == msg.bot_id:
+                return True
+        return False
+    return True
+
+
+def _cast_segment(data: dict) -> Optional[BaseSegment]:
+    """按 type 字段实例化对应段模型；未知或校验失败返回 None。"""
+    cls = SEGMENT_MAP.get(data["type"])
+    if not cls:
+        return None
+    try:
+        return cls(**data)
+    except Exception:
+        return None
+
+
+def _extract_mention_robot(
+    text: TextSegment, bot_name: str, bot_id: str
+) -> List[Union[TextSegment, AtSegment]]:
+    """把正文中「@昵称 」拆成文本段与 @ 段。"""
+
+    def split(text: TextSegment) -> List[Union[TextSegment, AtSegment]]:
+        content = text.text
+
+        keyword = f"@{bot_name} "
+        if keyword in content:
+            index = content.find(keyword)
+            before_text = content[:index]
+            after_text = content[index + len(keyword):]
+            return (
+                split(TextSegment(data={"text": before_text}))
+                + [AtSegment(data={"name": bot_name, "qq": bot_id})]
+                + split(TextSegment(data={"text": after_text}))
+            )
+        return [text]
+
+    try:
+        return split(text)
+    except Exception:
+        return [text]

python_library_lagrange_adapter-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: python-library-lagrange-adapter
+Version: 0.1.0
+Summary: Lagrange / aiocqhttp CQ 消息段与 OneBot 载荷互转及接入
+Requires-Python: >=3.10
+Requires-Dist: aiocqhttp
+Requires-Dist: pydantic<3,>=2.0
+Requires-Dist: python-library-onebot-protocol

python_library_lagrange_adapter-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+lagrange_adapter/__init__.py,sha256=iYOT58Voz7NrxvrUpv3iv4I-HYxsNd91iUdpooUzuLU,131
+lagrange_adapter/adapter.py,sha256=dlcdTD19CvGz5CZd82_1juOPtcOYu_TKpFh1WWCGL4w,4285
+lagrange_adapter/bot.py,sha256=llMdDPvcL8_jIDBZkuUtBWl21tWKRgFNFwel23fs0Vo,7100
+lagrange_adapter/listener.py,sha256=BjcfQs-M1_2m9tjUJOkfUilizpRftEiD9HfGoyv4KDA,3150
+lagrange_adapter/models.py,sha256=64Hc6jLWAM5RtxyhYpggdOxU_yMDn7F2zLAvXy_jzbs,4020
+lagrange_adapter/protocol_adapt.py,sha256=8Esf5elCjCH964x_hTNLKxumiox9qbwM5ZLo3Vg9y6E,5983
+python_library_lagrange_adapter-0.1.0.dist-info/METADATA,sha256=jbGHLW5wzIB3_zRPYQYgXWcZoARTvsVx7TKckJicBkQ,277
+python_library_lagrange_adapter-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+python_library_lagrange_adapter-0.1.0.dist-info/RECORD,,

python_library_lagrange_adapter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any