socket.d 2.4.10.4__tar.gz → 2.4.10.6__tar.gz

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: socket.d
-Version: 2.4.10.4
+Version: 2.4.10.6
 Summary: @noear/socket.d python project
 Home-page: https://socketd.noear.org/
 Author: noear,bai

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup,find_packages
 
 setup(
     name='socket.d',
-    version='2.4.10.4',
+    version='2.4.10.6',
     description='@noear/socket.d python project',
     author='noear,bai',
     url='https://socketd.noear.org/',

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socket.d.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: socket.d
-Version: 2.4.10.4
+Version: 2.4.10.6
 Summary: @noear/socket.d python project
 Home-page: https://socketd.noear.org/
 Author: noear,bai

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/client/ClientBase.py

@@ -11,10 +11,10 @@ from socketd.transport.core.ChannelAssistant import ChannelAssistant
 from socketd.transport.core.Costants import Constants
 from socketd.transport.core.Session import Session
 from socketd.transport.client.ClientHeartbeatHandler import ClientHeartbeatHandler
+from socketd.transport.core.impl.LogConfig import log
 from socketd.transport.core.impl.ProcessorDefault import ProcessorDefault
 from socketd.transport.client.ClientConfig import ClientConfig
 
-from loguru import logger
 
 
 class ClientBase(ClientInternal, ABC):
@@ -76,13 +76,13 @@ class ClientBase(ClientInternal, ABC):
 
         try:
             await clientChannel.connect()
-            logger.info(f"Socket.D client successfully connected: link={self.get_config().get_link_url()}")
+            log.info(f"Socket.D client successfully connected: link={self.get_config().get_link_url()}")
         except Exception as e:
             if isThrow:
                 await clientChannel.close(code=Constants.CLOSE2008_OPEN_FAIL)
                 raise SocketDException(f"Socket.D client Connection failed {e}")
             else:
-                logger.info(f"Socket.D client Connection failed: link={self.get_config().get_link_url()}")
+                log.info(f"Socket.D client Connection failed: link={self.get_config().get_link_url()}")
 
         return clientChannel.get_session()
 

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/client/ClientChannel.py

@@ -6,11 +6,11 @@ from socketd.transport.client.Client import ClientInternal
 from socketd.transport.core.Asserts import Asserts
 from socketd.transport.core.ChannelInternal import ChannelInternal
 from socketd.transport.core.Costants import Constants
+from socketd.transport.core.impl.LogConfig import log
 from socketd.transport.core.impl.SessionDefault import SessionDefault
 from socketd.transport.stream.StreamManger import StreamInternal
 from socketd.transport.core.impl.ChannelBase import ChannelBase
 from socketd.transport.client.ClientConnector import ClientConnector
-from loguru import logger
 
 from socketd.transport.client.ClientHeartbeatHandler import ClientHeartbeatHandlerDefault
 from socketd.transport.utils.sync_api.AtomicRefer import AtomicRefer
@@ -40,7 +40,7 @@ class ClientChannel(ChannelBase):
             if not self.__heartbeatScheduledFuture.done():
                 self.__heartbeatScheduledFuture.cancel()
         except Exception as e:
-            logger.warning(e)
+            log.warning(e)
 
     async def __heartbeatScheduled(self) -> None:
         while True:
@@ -60,7 +60,7 @@ class ClientChannel(ChannelBase):
                 return
 
             if Asserts.is_closed_and_end(self.__real):
-                logger.debug("Client channel is closed (pause heartbeat), sessionId=" + self.get_session().session_id())
+                log.debug("Client channel is closed (pause heartbeat), sessionId=" + self.get_session().session_id())
                 await self.close(self.__real.is_closed())
                 return
 
@@ -136,7 +136,7 @@ class ClientChannel(ChannelBase):
             if self.__real:
                 await self.__real.close(code)
         except Exception as e:
-            logger.error(e)
+            log.error(e)
         finally:
             await super().close(code)
 
@@ -150,7 +150,7 @@ class ClientChannel(ChannelBase):
         self.init_heartbeat()
         await self.internalCheck()
 
-    @logger.catch
+    @log.catch
     async def connect(self):
         with self.__isConnecting as isConnected:
             if isConnected:
@@ -166,9 +166,9 @@ class ClientChannel(ChannelBase):
             self.__real.set_session(self.__sessionShell)
             self.set_handshake(self.__real.get_handshake())
         except TimeoutError as t:
-            logger.error(f"socketD connect timed out: {t}")
+            log.error(f"socketD connect timed out: {t}")
         except Exception as e:
-            logger.error(e)
+            log.error(e)
             raise SocketDChannelException(f"socketD connect")
         finally:
             self.__isConnecting.set(False)

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/core/Channel.py

@@ -87,7 +87,7 @@ class Channel(ABC):
         ...
 
     @abstractmethod
-    def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
+    async def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
         ...
 
     @abstractmethod

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/core/impl/ChannelDefault.py

@@ -106,7 +106,7 @@ class ChannelDefault(ChannelBase, ChannelInternal):
         if stream is not None:
             stream.on_progress(True, 1, 1)
 
-    def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
+    async def retrieve(self, frame: Frame, stream: StreamInternal) -> None:
         """接收（接收答复帧）"""
         if stream is not None:
             if stream.demands() < Constants.DEMANDS_MULTIPLE or frame.flag() == Flags.ReplyEnd:
@@ -115,11 +115,11 @@ class ChannelDefault(ChannelBase, ChannelInternal):
 
             if stream.demands() < Constants.DEMANDS_MULTIPLE:
                 # 单收时，内部已经是异步机制
-                stream.on_reply(frame.message())
+                await stream.on_reply(frame.message())
             else:
-                #stream.on_reply(frame.message())
                 # 改为异步处理，避免卡死Io线程
-                asyncio.get_running_loop().run_in_executor(self.get_config().get_exchange_executor(), lambda _m: asyncio.run(stream.on_reply(_m)), frame.message())
+                asyncio.get_running_loop().run_in_executor(self.get_config().get_exchange_executor(),
+                                                           lambda _m: asyncio.run(stream.on_reply(_m)), frame.message())
         else:
             log.debug(
                 f"{self.get_config().get_role_name()} stream not found, sid={frame.message().sid()}, sessionId={self.get_session().session_id()}")

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/core/impl/LogConfig.py

@@ -2,10 +2,12 @@
 from loguru import logger as _logger
 
 import logging
+
 # socket.d 默认
 logger = logging.getLogger("socketD")
 # 异步默认日志
 logging.getLogger("asyncio").setLevel(logging.WARNING)
 # 少用默认logging ，因为他会阻塞你的线程
-
-log = _logger.opt()
+# 删除原本的处理器
+_logger.remove()
+log = _logger.opt(colors=True)

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/core/impl/ProcessorDefault.py

@@ -1,8 +1,6 @@
 import asyncio
 from abc import ABC
-from typing import Optional, Union
-
-from loguru import logger
+from typing import Optional
 
 from socketd.exception.SocketDExecption import SocketDAlarmException, SocketDConnectionException
 from socketd.transport.core.ChannelInternal import ChannelInternal
@@ -13,17 +11,15 @@ from socketd.transport.core.Costants import Constants
 from socketd.transport.core.Flags import Flags
 from socketd.transport.core.EntityMetas import EntityMetas
 from socketd.transport.core.Frame import Frame
+from socketd.transport.core.impl.LogConfig import log
 from socketd.transport.core.listener.SimpleListener import SimpleListener
-from socketd.transport.stream.Stream import Stream
 from socketd.transport.stream.StreamManger import StreamInternal
-from socketd.transport.utils.AsyncUtil import AsyncUtil
 
 
 class ProcessorDefault(Processor, ABC):
 
     def __init__(self):
         self.listener = SimpleListener()
-        self.log = logger.opt()
 
     def set_listener(self, listener):
         if listener is not None:
@@ -31,9 +27,9 @@ class ProcessorDefault(Processor, ABC):
 
     async def on_receive(self, channel: ChannelInternal, frame):
         if channel.get_config().client_mode():
-            logger.debug(f"C-REV:{frame}")
+            log.debug(f"C-REV:{frame}")
         else:
-            logger.debug(f"S-REV:{frame}")
+            log.debug(f"S-REV:{frame}")
 
         if frame.flag() == Flags.Connect:
             # if server
@@ -42,7 +38,7 @@ class ProcessorDefault(Processor, ABC):
 
             async def _future(r: bool, e: Exception):
                 if r:
-                    #如果无异常
+                    # 如果无异常
                     if channel.is_valid():
                         try:
                             await channel.send_connack(connectMessage)
@@ -67,7 +63,8 @@ class ProcessorDefault(Processor, ABC):
                 if frame.flag() == Flags.Close:
                     raise SocketDConnectionException("Connection request was rejected")
 
-                self.log.warning("{} channel handshake is None, sessionId={}", channel.get_config().get_role_name(), channel.get_session().session_id())
+                log.warning("{} channel handshake is None, sessionId={}", channel.get_config().get_role_name(),
+                                 channel.get_session().session_id())
                 return
 
             # 更新最后活动时间
@@ -79,9 +76,9 @@ class ProcessorDefault(Processor, ABC):
                 elif frame.flag() == Flags.Pong:
                     pass
                 elif frame.flag() == Flags.Close:
-                    code:int = 0
+                    code: int = 0
 
-                    if frame.message()  is not None:
+                    if frame.message() is not None:
                         code = frame.message().meta_as_int("code")
 
                     if code == 0:
@@ -141,7 +138,7 @@ class ProcessorDefault(Processor, ABC):
         if isReply:
             if stream:
                 stream.on_progress(False, streamIndex, streamTotal)
-            channel.retrieve(frame, stream)
+            await channel.retrieve(frame, stream)
         else:
             self.on_message(channel, frame.message())
 
@@ -153,7 +150,7 @@ class ProcessorDefault(Processor, ABC):
             await self.listener.on_open(channel.get_session())
             channel.do_open_future(True, None)
         except Exception as e:
-            logger.warning("{} channel listener onOpen error", channel.get_config().get_role_name(), e)
+            log.warning("{} channel listener onOpen error", channel.get_config().get_role_name(), e)
             channel.do_open_future(False, e)
 
     def on_message(self, channel: ChannelInternal, message: Message):
@@ -163,12 +160,12 @@ class ProcessorDefault(Processor, ABC):
         try:
             await self.listener.on_message(channel.get_session(), message)
         except Exception as e:
-            logger.warning("{} channel listener onMessage error", channel.get_config().get_role_name(), e)
+            log.warning("{} channel listener onMessage error", channel.get_config().get_role_name(), e)
             self.on_error(channel, e)
 
     def on_close(self, channel: ChannelInternal):
         if channel.is_closed() <= Constants.CLOSE1000_PROTOCOL_CLOSE_STARTING:
-            self.on_close_internal(channel, Constants.CLOSE2003_DISCONNECTION)
+            asyncio.create_task(self.on_close_internal(channel, Constants.CLOSE2003_DISCONNECTION))
 
     async def on_close_internal(self, channel: ChannelInternal, code: int):
         await channel.close(code)
@@ -178,4 +175,3 @@ class ProcessorDefault(Processor, ABC):
 
     def on_error(self, channel: ChannelInternal, error):
         self.listener.on_error(channel.get_session(), error)
-

socket.d-2.4.10.6/socketd/transport/core/listener/EventListener.py

@@ -0,0 +1,57 @@
+from typing import Callable, Union, Dict
+
+from socketd.transport.core.Listener import Listener
+from socketd.transport.core.Session import Session
+from socketd.transport.core.Message import Message
+
+
+class EventListener(Listener):
+    """
+    @author bai
+    @since 2.0
+    """
+
+    def __init__(self):
+        self._doOnOpenHandler: Union[Callable[[Session], None], None] = None
+        self._doOnMessageHandler: Union[Callable[[Session, Message], None], None] = None
+        self._doOnCloseHandler: Union[Callable[[Session], None], None] = None
+        self._doOnErrorHandler: Union[Callable[[Session, Exception], None], None] = None
+        self._eventRouteSelector: Union[Dict[str, Callable[[Session, Message], None]], None] = None
+
+    def do_on_open(self, _on_open_handler: Callable[[Session, Message], None]) -> 'EventListener':
+        self._doOnOpenHandler = _on_open_handler
+        return self
+
+    def do_on_message(self, _on_message_handler: Callable[[Session], None]) -> 'EventListener':
+        self._doOnMessageHandler = _on_message_handler
+        return self
+
+    def do_on_close(self, _on_close_handler: Callable[[Session, Exception], None]) -> 'EventListener':
+        self._doOnCloseHandler = _on_close_handler
+        return self
+
+    def do_on_error_handler(self, _on_error_handler: Callable[[Session, Exception], None]) -> 'EventListener':
+        self._doOnErrorHandler = _on_error_handler
+        return self
+
+    def do_on(self, event: str, handler: Callable[[Session, Message], None]):
+        self._eventRouteSelector[event] = handler
+
+    async def on_open(self, session: Session):
+        if self._doOnOpenHandler:
+            self._doOnOpenHandler(session)
+
+    async def on_message(self, session: Session, message: Message):
+        if self._doOnMessageHandler:
+            self._doOnMessageHandler(session, message)
+
+        if message_handler := self._eventRouteSelector.get(message.event()):
+            message_handler(session, message)
+
+    def on_close(self, session: Session):
+        if self._doOnCloseHandler:
+            self._doOnCloseHandler(session)
+
+    def on_error(self, session: Session, error: Exception):
+        if self._doOnErrorHandler:
+            self._doOnErrorHandler(session, error)

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd/transport/server/Server.py

@@ -7,18 +7,25 @@ from websockets.sync.server import WebSocketServer
 from socketd.transport.server.ServerConfig import ServerConfig
 from socketd.transport.core.Listener import Listener
 
-
+#服务端接口
 class Server:
+    #获取台头
     def get_title(self): ...
 
+    #获取配置
     def get_config(self) -> ServerConfig: ...
 
+    #配置
     def config(self, consumer: Callable[[ServerConfig], None]) -> Server: ...
 
+    #监听
     def listen(self, listener: Listener) -> Server: ...
 
+    #启动
     def start(self) -> WebSocketServer | Coroutine: ...
 
+    #预停止
     def prestop(self) -> Coroutine: ...
 
+    #停止
     def stop(self) -> Coroutine: ...

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd_aio_tcp/TcpAioClientConnector.py

@@ -36,7 +36,7 @@ class TcpAioClientConnector(ClientConnectorBase):
     async def connect(self):
         # 处理自定义架构的影响
         loop = asyncio.get_running_loop()
-        tcp_url = self.client.get_config().get_url().replace("std:", "").replace("-python", "")
+        tcp_url = self.client.get_config().get_url().replace("-python", "")
         _sch, _host, _port = tcp_url.replace("//", "").split(":")
         _port = int(_port.split("/")[0])
         if self.__top is None:

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd_websocket/WsAioClientConnector.py

@@ -25,7 +25,7 @@ class WsAioClientConnector(ClientConnectorBase):
 
     async def connect(self) -> Channel:
         # 关闭之前的资源
-        self.close()
+        await self.close()
 
         # 处理自定义架构的影响
         ws_url = self.client.get_config().get_url().replace("-python://", "://")

{socket.d-2.4.10.4 → socket.d-2.4.10.6}/socketd_websocket/impl/AIOWebSocketClientImpl.py

@@ -128,7 +128,8 @@ class AIOWebSocketClientImpl(WebSocketClientProtocol):
     async def on_close(self):
         await self.client.get_processor().on_close(self.channel)
         if self.handshake_future is not None:
-            await asyncio.wait(self.__on_receive_tasks, timeout=10)
+            if self.__on_receive_tasks:
+                await asyncio.wait(self.__on_receive_tasks, timeout=10)
             await asyncio.wait([self._handler_future], timeout=10)
 
     def on_error(self, e):

socket.d-2.4.10.4/socketd/transport/core/listener/EventListener.py

@@ -1,57 +0,0 @@
-from typing import Callable, Union, Dict
-
-from socketd.transport.core.Listener import Listener
-from socketd.transport.core.Session import Session
-from socketd.transport.core.Message import Message
-
-
-class EventListener(Listener):
-    """
-    @author bai
-    @since 2.0
-    """
-
-    def __init__(self):
-        self._do_on_open_handler: Union[Callable[[Session], None], None] = None
-        self._do_on_message_handler: Union[Callable[[Session, Message], None], None] = None
-        self._do_on_close_handler: Union[Callable[[Session], None], None] = None
-        self._do_on_error_handler: Union[Callable[[Session, Exception], None], None] = None
-        self._do_on_message_routing: Union[Dict[str, Callable[[Session, Message], None]], None] = None
-
-    def do_on_open_handler(self, _on_open_handler: Callable[[Session, Message], None]) -> 'EventListener':
-        self._do_on_open_handler = _on_open_handler
-        return self
-
-    def do_on_message_handler(self, _on_message_handler: Callable[[Session], None]) -> 'EventListener':
-        self._do_on_message_handler = _on_message_handler
-        return self
-
-    def do_on_close_handler(self, _on_close_handler: Callable[[Session, Exception], None]) -> 'EventListener':
-        self._do_on_close_handler = _on_close_handler
-        return self
-
-    def do_on_error_handler(self, _on_error_handler: Callable[[Session, Exception], None]) -> 'EventListener':
-        self._do_on_error_handler = _on_error_handler
-        return self
-
-    def do_on(self, event: str, handler: Callable[[Session, Message], None]):
-        self._do_on_message_routing[event] = handler
-
-    async def on_open(self, session: Session):
-        if self._do_on_open_handler:
-            self._do_on_open_handler(session)
-
-    async def on_message(self, session: Session, message: Message):
-        if self._do_on_message_handler:
-            self._do_on_message_handler(session, message)
-
-        if message_handler := self._do_on_message_routing.get(message.event()):
-            message_handler(session, message)
-
-    def on_close(self, session: Session):
-        if self._do_on_close_handler:
-            self._do_on_close_handler(session)
-
-    def on_error(self, session: Session, error: Exception):
-        if self._do_on_error_handler:
-            self._do_on_error_handler(session, error)