PyPI - socket-cyg - Versions diffs - 0.1.6__tar.gz → 1.0.0__tar.gz - Mend

socket-cyg 0.1.6tar.gz → 1.0.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: socket-cyg
-Version: 0.1.6
+Version: 1.0.0
 Summary: CYG socket 封装
 Author: LiuWei
 Author-email: 183074632@qq.com

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "socket-cyg"
-version = "0.1.6"
+version = "1.0.0"
 description = "CYG socket 封装"
 authors = ["LiuWei <183074632@qq.com>"]
 readme = "README.md"

socket_cyg-1.0.0/socket_cyg/example/client_example.py ADDED Viewed

@@ -0,0 +1,18 @@
+# pylint: skip-file
+import time
+from socket_cyg.socket_client import SocketClient
+if __name__ == "__main__":
+    def my_callback(data: bytes):
+        """示例回调函数。"""
+        print(f"回调收到数据: {data.decode('UTF-8')}")
+    client = SocketClient("127.0.0.1", 9001, my_callback)
+    if client.connect():
+        try:
+            client.send_data(b"ffffff")
+            time.sleep(500000)
+        finally:
+            client.disconnect()

socket_cyg-1.0.0/socket_cyg/socket_client.py ADDED Viewed

@@ -0,0 +1,126 @@
+# pylint: skip-file
+import socket
+import threading
+import logging
+from typing import Callable, Optional
+class SocketClient:
+    """用于持续与服务器通信的 TCP Socket 客户端."""
+    def __init__(self, host: str, port: int,
+                 receive_callback: Optional[Callable[[bytes], None]] = None,
+                 buffer_size: int = 1024):
+        """初始化 Socket 客户端.
+        Args:
+            host: 要连接的服务器主机名或 IP 地址.
+            port: 服务器端口号.
+            receive_callback: 处理接收数据的回调函数, 回调函数应接受 bytes 类型作为唯一参数.
+            buffer_size: 接收缓冲区大小（字节）,默认为 1024.
+        """
+        self.host = host
+        self.port = port
+        self.buffer_size = buffer_size
+        self.receive_callback = receive_callback
+        self.socket = None
+        self.is_connected = False
+        self.receive_thread = None
+        self.logger = logging.getLogger(self.__class__.__name__)
+    def connect(self) -> bool:
+        """建立与服务器的连接, 连接成功后会自动启动后台线程持续接收数据.
+        Returns:
+            bool: 连接成功返回 True,否则返回 False.
+        """
+        try:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.connect((self.host, self.port))
+            self.is_connected = True
+            self.logger.info("已连接到服务器 %s: %s", self.host, self.port)
+            self.receive_thread = threading.Thread(
+                target=self._receive_data,
+                daemon=True
+            )
+            self.receive_thread.start()
+            return True
+        except Exception as e:
+            self.logger.warning("连接失败, %s", str(e))
+            self.is_connected = False
+            return False
+    def disconnect(self):
+        """断开与服务器的连接并释放资源."""
+        if self.is_connected:
+            self.is_connected = False
+            try:
+                if self.socket:
+                    self.socket.close()
+                if self.receive_thread and self.receive_thread.is_alive():
+                    self.receive_thread.join(timeout=1)
+            except Exception as e:
+                self.logger.warning("断开连接时出错: %s", str(e))
+            finally:
+                self.logger.info("已断开与服务器的连接")
+    def send_data(self, data: bytes) -> bool:
+        """向服务器发送数据.
+        Args:
+            data: 要发送的字节数据.
+        Returns:
+            发送成功返回 True,失败返回 False.
+        Raises:
+            无显式抛出异常,但内部错误会打印到控制台.
+        """
+        if not self.is_connected:
+            self.logger.warning("未连接到服务器")
+            return False
+        try:
+            self.socket.sendall(data)
+            return True
+        except Exception as e:
+            self.logger.warning("发送数据出错: %s", str(e))
+            self.disconnect()
+            return False
+    def _receive_data(self):
+        """持续接收数据的内部方法."""
+        while self.is_connected:
+            try:
+                data = self.socket.recv(self.buffer_size)
+                if not data:  # 服务器关闭连接
+                    self.logger.info("服务器关闭了连接")
+                    self.disconnect()
+                    break
+                if self.receive_callback:
+                    self.logger.info("收到数据: %s", data)
+                    self.logger.info("触发回调函数")
+                    self.receive_callback(data)
+                else:
+                    self.logger.info("收到数据: %s", data)
+            except ConnectionResetError:
+                self.logger.warning("连接被服务器重置")
+                self.disconnect()
+                break
+            except Exception as e:
+                if self.is_connected:
+                    self.logger.warning("接收数据出错: %s", str(e))
+                    self.disconnect()
+                break
+    def __enter__(self):
+        """实现上下文管理协议,进入时自动连接."""
+        self.connect()
+        return self
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """实现上下文管理协议,退出时自动断开连接."""
+        self.disconnect()

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/socket_cyg/socket_server_asyncio.py RENAMED Viewed

@@ -1,3 +1,4 @@
+# pylint: skip-file
 """异步socket."""
 import asyncio
 import datetime
@@ -7,10 +8,8 @@ import socket
 import sys
 from asyncio import AbstractEventLoop
 from logging.handlers import TimedRotatingFileHandler
-from typing import Union
-# pylint: disable=R0801, disable=R0902
 class CygSocketServerAsyncio:
     """异步socket class."""
     LOG_FORMAT = "%(asctime)s - %(levelname)s - %(module)s:%(lineno)d - %(message)s"
@@ -19,15 +18,12 @@ class CygSocketServerAsyncio:
     tasks = {}
     loop: AbstractEventLoop = None
-    def __init__(self, address="127.0.0.1", port=8000, key_value_split=b"-_-", end_identifier=b"@_@"):
+    def __init__(self, address="127.0.0.1", port=8000):
         self._address = address
         self._port = port
-        self._key_value_split = key_value_split
-        self._end_identifier = end_identifier
         self._logger = logging.getLogger(f"{self.__module__}.{self.__class__.__name__}")
         self._file_handler = None
         self.set_log()
-        self.queue = asyncio.Queue()
     def set_log(self):
         """设置日志."""
@@ -60,68 +56,54 @@ class CygSocketServerAsyncio:
         """日志实例."""
         return self._logger
-    async def consumer(self, operation_func: callable):
-        """获取队列里客户端发来的数据进行处理.
+    def operations_return_data(self, data: bytes):
+        """操作返回数据."""
+        data = data.decode("UTF-8")
+        self._logger.warning("*** 回显 *** -> 没有重写 operations_return_data 函数, 默认是回显.")
+        return data
-        Args:
-            operation_func: 处理函数.
-        """
-        while True:
-            while self.queue.qsize() != 0:
-                data = await self.queue.get()
-                operation_func(data)
-                self.queue.task_done()
-    async def socket_send(self, client_connection, data: Union[bytes, str]):
+    async def socket_send(self, client_connection, data: bytes):
         """发送数据给客户端."""
-        if isinstance(data, str):
-            data = data.encode("UTF-8")
         if client_connection:
             client_ip = client_connection.getpeername()
             await self.loop.sock_sendall(client_connection, data)
-            self._logger.info("*** 发送 *** --> %s 发送成功, %s", client_ip, data)
+            self._logger.info("***发送*** --> %s 发送成功, %s", client_ip, data)
         else:
-            self._logger.info("*** 发送 *** --> 发送失败, %s, 未连接", data)
+            self._logger.info("***发送*** --> 发送失败, %s, 未连接", data)
     async def receive_send(self, client_connection: socket.socket):
         """接收发送数据."""
         client_ip = client_connection.getpeername()[0]  # 获取连接客户端的ip
-        self._logger.info("%s 处理 %s 客户端的任务开始 %s", "-" * 30, client_ip, "-" * 30)
-        buffer_byte = b""
         try:
-            while data_byte := await self.loop.sock_recv(client_connection, 1024 * 1024):
-                buffer_byte += data_byte
-                if self._end_identifier in buffer_byte:
-                    await self.socket_send(client_connection, b"^_^")
-                    one_message_byte, remaining = buffer_byte.split(self._end_identifier, 1)
-                    buffer_byte = remaining
-                    keys, datas = one_message_byte.split(self._key_value_split, 1)
-                    await self.queue.put({keys: datas})
-                    self._logger.info("*** 将一条完整消息放入队列 ***")
-                    self._logger.info("keys: %s", keys)
-                    self._logger.info("datas: %s", datas[:129:])
+            while data := await self.loop.sock_recv(client_connection, 1024 * 1024):
+                self._logger.info("%s", '-' * 60)
+                self._logger.info("***Socket接收*** --> %s, 数据: %s", client_ip, data.decode('UTF-8'))
+                send_data = self.operations_return_data(data)  # 这个方法实现具体业务, 需要重写, 不重写回显
+                send_data_byte = send_data.encode("UTF-8") + b"\r\n"
+                await self.loop.sock_sendall(client_connection, send_data_byte)
+                self._logger.info("***Socket回复*** --> %s, 数据: %s", client_ip, send_data)
+                self._logger.info("%s", '-' * 60)
         except Exception as e:  # pylint: disable=W0718
-            self._logger.warning("*** 通讯出现异常 *** --> 异常信息是: %s", e)
+            self._logger.warning("***通讯出现异常*** --> 异常信息是: %s", e)
         finally:
             self.clients.pop(client_ip)
             self.tasks.get(client_ip).cancel()
-            self._logger.warning("*** 下位机断开 *** --> %s, 断开了", client_ip)
-            self._logger.info("%s 处理 %s 客户端的任务结束 %s", "-" * 30, client_ip, "-" * 30)
+            self._logger.warning("***下位机断开*** --> %s, 断开了", client_ip)
             client_connection.close()
     async def listen_for_connection(self, socket_server: socket):
         """异步监听连接."""
-        self._logger.info("*** 服务端已启动 *** --> %s 等待客户端连接", socket_server.getsockname())
+        self._logger.info("***服务端已启动*** --> %s 等待客户端连接", socket_server.getsockname())
         while True:
             self.loop = asyncio.get_running_loop()
             client_connection, address = await self.loop.sock_accept(socket_server)
-            self._logger.warning("*** 下位机连接 *** --> %s, 连接了", address)
             client_connection.setblocking(False)
-            await self.socket_send(client_connection, "^_^")
             self.clients.update({address[0]: client_connection})
-            self.tasks.update({address[0]: self.loop.create_task(self.receive_send(client_connection))})
-            self._logger.warning("*** 创建了处理 %s 客户端的任务 ***", address)
+            self.tasks.update({
+                address[0]: self.loop.create_task(self.receive_send(client_connection))
+            })
+            self._logger.warning("***下位机连接*** --> %s, 连接了", address)
     async def run_socket_server(self):
         """运行socket服务, 并监听客户端连接."""

socket_cyg-0.1.6/socket_cyg/example/client_example.py DELETED Viewed

@@ -1,43 +0,0 @@
-"""client_example."""
-import os
-from socket_cyg.socket_client import SocketClient
-FILE_PATH = r"D:\python_workspace\equipment_cyg.rar"
-if __name__ == '__main__':
-    client1 = SocketClient()
-    client1.client_open()
-    client1.run_receive_thread()
-    with open(FILE_PATH, mode="rb+") as f:
-        data = f.read()
-        dir_path = f"{os.getcwd()}/a"
-        client1.client_send(dir_path.encode("UTF-8") + b"-_-" + data + b"@__@")
-    client2 = SocketClient()
-    client2.client_open()
-    client2.run_receive_thread()
-    with open(FILE_PATH, mode="rb+") as f:
-        data = f.read()
-        dir_path = f"{os.getcwd()}/b"
-        client2.client_send(dir_path.encode("UTF-8") + b"-_-" + data + b"@__@")
-    client3 = SocketClient()
-    client3.client_open()
-    client3.run_receive_thread()
-    with open(FILE_PATH, mode="rb+") as f:
-        data = f.read()
-        dir_path = f"{os.getcwd()}/c"
-        client3.client_send(dir_path.encode("UTF-8") + b"-_-" + data + b"@__@")
-    client4 = SocketClient()
-    client4.client_open()
-    client4.run_receive_thread()
-    with open(FILE_PATH, mode="rb+") as f:
-        data = f.read()
-        dir_path = f"{os.getcwd()}/d"
-        client4.client_send(dir_path.encode("UTF-8") + b"-_-" + data + b"@__@")

socket_cyg-0.1.6/socket_cyg/example/server_example.py DELETED Viewed

@@ -1,31 +0,0 @@
-"""server_example."""
-import asyncio
-import os.path
-import threading
-from socket_cyg.socket_server_asyncio import CygSocketServerAsyncio
-def save(data):
-    """保存文件的函数."""
-    dir_path, datas = list(data.keys())[0], list(data.values())[0]
-    dir_path = dir_path.decode("UTF-8")
-    if not os.path.exists(dir_path):
-        os.makedirs(dir_path)
-    with open(f"{dir_path}/a.rar", "ab+") as f:
-        f.write(datas)
-if __name__ == '__main__':
-    server = CygSocketServerAsyncio(end_identifier=b"@__@")
-    def run_server():
-        """启动server."""
-        asyncio.run(server.run_socket_server())
-    def run_consumer():
-        """启动消费队列."""
-        asyncio.run(server.consumer(save))
-    threading.Thread(target=run_server).start()
-    threading.Thread(target=run_consumer).start()

socket_cyg-0.1.6/socket_cyg/socket_client.py DELETED Viewed

@@ -1,125 +0,0 @@
-"""socket 客户端."""
-import datetime
-import os
-import socket
-import sys
-import threading
-import logging
-from logging.handlers import TimedRotatingFileHandler
-from typing import Union
-class SocketClient:
-    """socket 客户端class."""
-    LOG_FORMAT = "%(asctime)s - %(levelname)s - %(module)s:%(lineno)d - %(message)s"
-    def __init__(self, host="127.0.0.1", port=8000):
-        self._logger = logging.getLogger(f"{self.__module__}.{self.__class__.__name__}")
-        self._file_handler = None
-        self.set_log()
-        self._host = host
-        self._port = port
-        self._client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    def set_log(self):
-        """设置日志."""
-        self.file_handler.setFormatter(logging.Formatter(self.LOG_FORMAT))
-        self.file_handler.setLevel(logging.INFO)
-        self.logger.addHandler(self.file_handler)
-        if sys.version_info.minor == 11:
-            logging.basicConfig(level=logging.INFO, encoding="UTF-8", format=self.LOG_FORMAT)
-        else:
-            console_handler = logging.StreamHandler()
-            console_handler.setFormatter(logging.Formatter(self.LOG_FORMAT))
-            console_handler.setLevel(logging.INFO)
-            self.logger.addHandler(console_handler)
-            self.logger.setLevel(logging.INFO)
-    @property
-    def file_handler(self):
-        """保存日志的日志处理器."""
-        if self._file_handler is None:
-            log_dir = f"{os.getcwd()}/log"
-            os.makedirs(log_dir, exist_ok=True)
-            file_name = f"{log_dir}/{datetime.datetime.now().strftime('%Y-%m-%d')}_{os.path.basename(os.getcwd())}.log"
-            self._file_handler = TimedRotatingFileHandler(
-                file_name, when="D", interval=1, backupCount=10, encoding="UTF-8"
-            )
-        return self._file_handler
-    @property
-    def logger(self):
-        """日志器."""
-        return self._logger
-    @property
-    def host(self):
-        """服务端ip."""
-        return self._host
-    @host.setter
-    def host(self, host):
-        """设置连接的服务端ip."""
-        self._host = host
-    @property
-    def port(self):
-        """服务端端口号."""
-        return self._port
-    @port.setter
-    def port(self, port):
-        """设置要连接的服务端端口号."""
-        self._port = port
-    @property
-    def client(self):
-        """客户端socket实例."""
-        return self._client
-    @client.setter
-    def client(self, client: socket):
-        """设置客户端socket实例."""
-        self._client = client
-    def client_open(self):
-        """连接服务端."""
-        self.client.connect((self.host, self.port))
-        self._logger.info("*** 和服务端连接成功 ***")
-    def client_close(self):
-        """关闭客户端连接."""
-        self.client.close()
-        self._logger.warning("*** 客户端关闭连接 ***")
-    def client_send(self, message: Union[str, bytes]):
-        """客户端发送数据."""
-        if isinstance(message, str):
-            message = message.encode("UTF-8")
-        self.client.sendall(message)
-        self._logger.info("*** 客户端发送数据 *** -> data: %s", message[:129:])
-    def client_receive(self):
-        """客户端接收数据."""
-        try:
-            while True:
-                data = self.client.recv(1024)
-                if not data:
-                    break
-                str_data = data.decode("utf-8")
-                self._logger.info("*** 客户端接收到服务端数据 *** -> data: %s", str_data)
-                self.operations()
-        except Exception as e:  # pylint: disable=W0718
-            self._logger.warning("*** 出现异常 *** -> 异常信息: %s", str(e))
-        finally:
-            self.client.close()
-    def operations(self):
-        """根据服务端发过来的数据进行的操作"""
-    def run_receive_thread(self):
-        """启动客户端线程, 实时监听服务端发来的数据."""
-        thread = threading.Thread(target=self.client_receive, daemon=False)
-        thread.start()

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/README.md RENAMED Viewed

File without changes

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/socket_cyg/__init__.py RENAMED Viewed

File without changes

{socket_cyg-0.1.6 → socket_cyg-1.0.0}/socket_cyg/example/__init__.py RENAMED Viewed

File without changes

socket-cyg 0.1.6__tar.gz → 1.0.0__tar.gz

socket-cyg 0.1.6tar.gz → 1.0.0tar.gz