peer-protocol 0.0.2__tar.gz

peer_protocol-0.0.2/.gitignore

@@ -0,0 +1 @@
+dist/

peer_protocol-0.0.2/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: peer-protocol
+Version: 0.0.2
+Summary: 既能做客户端也能做服务端
+Project-URL: Repository, https://github.com/XiaoHui2023/peer-protocol
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Description-Content-Type: text/markdown
+
+# peer-protocol

peer_protocol-0.0.2/README.md

@@ -0,0 +1 @@
+# peer-protocol

peer_protocol-0.0.2/peer_protocol/__init__.py

@@ -0,0 +1,5 @@
+from .peer import Peer
+
+__all__ = [
+    "Peer",
+]

peer_protocol-0.0.2/peer_protocol/client.py

@@ -0,0 +1,190 @@
+import asyncio
+import json
+import logging
+import aiohttp
+from typing import Optional, Any
+from urllib.parse import urlparse, ParseResult
+from .peer import Peer
+
+logger = logging.getLogger(__name__)
+
+class Client(Peer):
+    def __init__(
+        self,
+        url: str="http://127.0.0.1:8080",
+        retry_interval: float = 2,
+        retry_timeout: float = 5,
+        *args,
+        **kwargs,
+    ):
+        """
+        Args:
+            url: 服务端 URL
+            retry_interval: 重试间隔时间
+            retry_timeout: 重试超时时间
+        Attributes:
+            _parsed_url: 解析后的 URL
+            _session: HTTP 会话
+            _ws: WebSocket 连接
+            _ws_task: WebSocket 任务
+            _running: 是否运行
+            _connected: 是否连接
+        """
+        super().__init__(*args, **kwargs)
+        self.url = url
+        self.retry_interval = retry_interval
+        self.retry_timeout = retry_timeout
+
+        self._parsed_url = self._parse_url(url)
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._ws_task: Optional[asyncio.Task] = None
+        self._running = False
+        self._connected = False
+
+    @property
+    def connected(self) -> bool:
+        """服务端是否在线"""
+        return self._connected
+
+    def _parse_url(self, url: str) -> ParseResult:
+        """解析 URL"""
+        url = url.strip().rstrip("/")
+        if url and not url.startswith(("http://", "https://")):
+            url = "http://" + url
+        parsed = urlparse(url)
+        if parsed.hostname is None:
+            raise ValueError(
+                f"无效的 url: {url!r}，"
+                "请使用完整 URL（如 http://127.0.0.1:8080）或 host:port 格式"
+            )
+        if parsed.port is None:
+            if parsed.scheme == "https":
+                port = 443
+            else:
+                port = 80
+            parsed = parsed._replace(port=port)
+        return parsed
+
+    async def _check_server(self) -> bool:
+        """纯 TCP 连通性检测：只检查服务端 IP:端口是否可达"""
+        host = self._parsed_url.hostname
+        port = self._parsed_url.port
+        try:
+            _, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port), timeout=self.retry_timeout
+            )
+            writer.close()
+            await writer.wait_closed()
+            return True
+        except Exception:
+            return False
+
+    async def _wait_for_server(self):
+        """轮询服务端，直到 TCP 可达（无限重试）"""
+        while self._running:
+            if await self._check_server():
+                return
+            await asyncio.sleep(self.retry_interval)
+
+    async def _ws_loop(self):
+        """WebSocket 连接循环：连接 → 收消息 → 断线重连"""
+        while self._running:
+            await self._wait_for_server()
+            if not self._running:
+                break
+
+            try:
+                self._ws = await self._session.ws_connect(self.url)
+            except Exception:
+                logger.exception("WebSocket 连接失败")
+                continue
+
+            self._connected = True
+            self._callback(self._on_connect, self._ws)
+
+            try:
+                async for msg in self._ws:
+                    if msg.type == aiohttp.WSMsgType.TEXT:
+                        asyncio.create_task(self._handle_message(msg.data))
+                    elif msg.type == aiohttp.WSMsgType.ERROR:
+                        logger.warning(f"WebSocket 连接异常: {self._ws.exception()}")
+                        break
+                    elif msg.type == aiohttp.WSMsgType.CLOSE:
+                        break
+            except Exception:
+                logger.exception("WebSocket 消息循环异常")
+            finally:
+                self._connected = False
+                if self._ws and not self._ws.closed:
+                    await self._ws.close()
+                self._ws = None
+                self._callback(self._on_disconnect, self._ws)
+
+    async def _handle_message(self, raw: str):
+        """解析服务端推送的消息，调用回调，发回回复"""
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as e:
+            logger.warning(f"收到无效的 JSON: {raw} - {e}")
+            return
+
+        self._callback(self._on_receive, data)
+
+    async def start(self):
+        """启动客户端"""
+        self._running = True
+        self._session = aiohttp.ClientSession()
+        self._ws_task = asyncio.create_task(self._ws_loop())
+        self._callback(self._on_start)
+
+    async def stop(self):
+        """停止客户端，清理所有资源"""
+        self._running = False
+
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+
+        if self._ws_task and not self._ws_task.done():
+            self._ws_task.cancel()
+            try:
+                await self._ws_task
+            except asyncio.CancelledError:
+                pass
+            self._ws_task = None
+
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+        self._callback(self._on_stop)
+
+    async def send(self, payload: Any):
+        """发送消息"""
+        self._callback(self._on_send, payload)
+
+        if self._ws and not self._ws.closed:
+            try:
+                await self._ws.send_str(json.dumps(payload, ensure_ascii=False))
+            except Exception:
+                logger.exception("发送消息失败")
+
+    def _render_callback(self):
+        """渲染回调"""
+        super()._render_callback()
+
+        @self.on_start
+        async def _():
+            logger.info(f"正在连接服务端: {self.url}")
+
+        @self.on_stop
+        async def _():
+            logger.info(f"停止客户端")
+
+        @self.on_connect
+        async def _(ws: aiohttp.ClientWebSocketResponse):
+            logger.info(f"连接到服务端: {self.url}")
+
+        @self.on_disconnect
+        async def _(ws: aiohttp.ClientWebSocketResponse):
+            logger.info(f"与服务端断开连接: {self.url}")

peer_protocol-0.0.2/peer_protocol/peer.py

@@ -0,0 +1,91 @@
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, Callable, Awaitable, Any
+from aiohttp import web
+
+logger = logging.getLogger(__name__)
+
+class Peer(ABC):
+    def __init__(self):
+        """
+        Attributes:
+            _on_start: 启动回调列表
+            _on_stop: 停止回调列表
+            _on_send: 发送消息回调列表
+            _on_receive: 接受消息回调列表
+            _on_connect: 连接成功回调列表
+            _on_disconnect: 连接断开回调列表
+            _runner: 应用运行器
+        """
+        self._on_start: list[Callable[[], Awaitable[None]]] = []
+        self._on_stop: list[Callable[[], Awaitable[None]]] = []
+        self._on_send: list[Callable[[Any], Awaitable[None]]] = []
+        self._on_receive: list[Callable[[Any], Awaitable[None]]] = []
+        self._on_connect: list[Callable[[Any], Awaitable[None]]] = []
+        self._on_disconnect: list[Callable[[Any], Awaitable[None]]] = []
+        self._runner: Optional[web.AppRunner] = None
+
+        self._render_callback()
+
+    def on_start(self, callback: Callable[[], Awaitable[None]]) -> None:
+        """注册启动回调"""
+        self._on_start.append(callback)
+
+    def on_stop(self, callback: Callable[[], Awaitable[None]]) -> None:
+        """注册停止回调"""
+        self._on_stop.append(callback)
+
+    def on_send(self, callback: Callable[[Any], Awaitable[None]]) -> None:
+        """注册发送消息回调"""
+        self._on_send.append(callback)
+
+    def on_receive(self, callback: Callable[[Any], Awaitable[None]]) -> None:
+        """注册接受消息回调"""
+        self._on_receive.append(callback)
+
+    def on_connect(self, callback: Callable[[Any], Awaitable[None]]) -> None:
+        """注册连接成功回调"""
+        self._on_connect.append(callback)
+
+    def on_disconnect(self, callback: Callable[[Any], Awaitable[None]]) -> None:
+        """注册连接断开回调"""
+        self._on_disconnect.append(callback)
+
+    def _callback(self, callbacks: list[Callable[[], Awaitable[None]]], *args: Any, **kwargs: Any) -> None:
+        for callback in callbacks:
+            try:
+                asyncio.create_task(callback(*args, **kwargs))
+            except:
+                logger.exception(f"回调函数执行失败: {callback}")
+                continue
+
+    @abstractmethod
+    def start(self) -> None:
+        """启动服务"""
+        pass
+
+    @abstractmethod
+    def stop(self) -> None:
+        """停止服务"""
+        pass
+            
+    async def run(self):
+        """启动服务并阻塞，直到中断"""
+        await self.start()
+        try:
+            await asyncio.Event().wait()
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self.stop()
+
+    def _render_callback(self):
+        """渲染回调"""
+        @self.on_send
+        async def _(payload: Any):
+            logger.info(f"发送消息: {payload}")
+
+        @self.on_receive
+        async def _(payload: Any):
+            logger.info(f"接收消息: {payload}")

peer_protocol-0.0.2/peer_protocol/server.py

@@ -0,0 +1,135 @@
+from .peer import Peer
+import logging
+import json
+import aiohttp
+from aiohttp import web
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+class Server(Peer):
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8080,
+        heartbeat: int = 120,
+        *args,
+        **kwargs,
+    ):
+        """
+        Args:
+            host: 主机地址
+            port: 端口号
+            heartbeat: 心跳间隔秒数
+        Attributes:
+            _clients: 客户端集合
+        """
+        super().__init__(*args, **kwargs)
+
+        self.host = host
+        self.port = port
+        self.heartbeat = heartbeat
+
+        self._clients: set[web.WebSocketResponse] = set()
+
+    def _disconnect(self, ws: web.WebSocketResponse):
+        """断开客户端连接"""
+        if ws not in self._clients:
+            return
+        self._clients.discard(ws)
+        self._callback(self._on_disconnect, ws)
+        
+    async def _handle_ws(self, request: web.Request) -> web.WebSocketResponse:
+        """WebSocket连接"""
+        ws = web.WebSocketResponse(heartbeat=self.heartbeat)
+        await ws.prepare(request)
+
+        self._clients.add(ws)
+        self._callback(self._on_connect, request)
+
+        try:
+            async for msg in ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    try:
+                        data = json.loads(msg.data)
+                    except json.JSONDecodeError as e:
+                        logger.warning(f"收到无效的 JSON: {msg.data} - {e}")
+                        continue
+                    except Exception as e:
+                        logger.warning(f"收到无效的消息: {msg.data} - {e}")
+                        continue
+                        
+                    self._callback(self._on_receive, data)
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    logger.warning(f"WebSocket 错误: {ws.exception()}")
+                    break
+                elif msg.type == aiohttp.WSMsgType.CLOSE:
+                    break
+        finally:
+            self._disconnect(ws)
+
+        return ws
+
+    async def broadcast(self, payload: Any) -> None:
+        """将消息广播给所有客户端 """
+        if not self._clients:
+            logger.warning("没有已连接的 WebSocket 客户端，无法转发消息")
+            return
+        
+        self._callback(self._on_send, payload)
+
+        dead: set[web.WebSocketResponse] = set()
+        for ws in self._clients:
+            try:
+                await ws.send_str(json.dumps(payload, ensure_ascii=False))
+            except Exception:
+                dead.add(ws)
+        for ws in dead:
+            self._disconnect(ws)
+
+    def _create_app(self) -> web.Application:
+        """创建应用"""
+        app = web.Application()
+        app.router.add_get("/ws", self._handle_ws)
+        return app
+
+    async def start(self):
+        """启动服务"""
+        app = self._create_app()
+        self._runner = web.AppRunner(app)
+        await self._runner.setup()
+        site = web.TCPSite(self._runner, self.host, self.port)
+        await site.start()
+        self._callback(self._on_start)
+
+    async def stop(self):
+        """停止服务"""
+        for ws in list(self._clients):
+            await ws.close()
+        self._clients.clear()
+
+        if self._runner:
+            await self._runner.cleanup()
+            self._runner = None
+
+        self._callback(self._on_stop)
+
+    def _render_callback(self):
+        """渲染回调"""
+        super()._render_callback()
+
+        @self.on_start
+        async def _():
+            logger.info(f"服务端已启动: {self.host}:{self.port}")
+
+        @self.on_stop
+        async def _():
+            logger.info(f"服务端已停止: {self.host}:{self.port}")
+
+        @self.on_connect
+        async def _(request: web.Request):
+            logger.info(f"客户端已连接: {request.remote}")
+
+        @self.on_disconnect
+        async def _(request: web.Request):
+            logger.info(f"客户端已断开: {request.remote}")

peer_protocol-0.0.2/publish.py

@@ -0,0 +1,60 @@
+"""
+PyPI 一键发布脚本
+自动递增补丁版本号并发布到 PyPI
+用法: python publish.py
+"""
+
+import re
+import subprocess
+import sys
+import shutil
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PYPROJECT = SCRIPT_DIR / "pyproject.toml"
+DIST_DIR = SCRIPT_DIR / "dist"
+
+
+def run(cmd: str):
+    print(f"\n>>> {cmd}")
+    result = subprocess.run(cmd, shell=True, cwd=SCRIPT_DIR)
+    if result.returncode != 0:
+        print(f"\n命令失败 (exit code: {result.returncode})")
+        sys.exit(result.returncode)
+
+
+def bump_version() -> str:
+    content = PYPROJECT.read_text(encoding="utf-8")
+    match = re.search(r'^version\s*=\s*"(\d+)\.(\d+)\.(\d+)"', content, re.MULTILINE)
+    if not match:
+        print("无法在 pyproject.toml 中找到版本号")
+        sys.exit(1)
+
+    major, minor, patch = int(match.group(1)), int(match.group(2)), int(match.group(3))
+    old_version = f"{major}.{minor}.{patch}"
+    new_version = f"{major}.{minor}.{patch + 1}"
+
+    new_content = content.replace(f'version = "{old_version}"', f'version = "{new_version}"')
+    PYPROJECT.write_text(new_content, encoding="utf-8")
+    return new_version
+
+
+def main():
+    new_version = bump_version()
+    print(f"版本号已更新为: {new_version}")
+
+    if DIST_DIR.exists():
+        print(f"清理 {DIST_DIR} ...")
+        shutil.rmtree(DIST_DIR)
+
+    print("开始构建...")
+    run("python -m build")
+
+    print("上传到 PyPI...")
+    run("python -m twine upload dist/*")
+
+    print("\n发布完成！")
+
+
+if __name__ == "__main__":
+    main()

peer_protocol-0.0.2/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "peer-protocol"
+version = "0.0.2"
+description = "既能做客户端也能做服务端"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [
+    "aiohttp>=3.9",
+]
+
+[project.urls]
+Repository = "https://github.com/XiaoHui2023/peer-protocol"
+
+[tool.hatch.build.targets.wheel]
+packages = ["peer_protocol"]