main.py

# client.py
import sys
import time
from PyQt5.QtCore import QCoreApplication, QDataStream, QIODevice, QByteArray
from PyQt5.QtNetwork import QLocalSocket
import json
import cal
import ast

class PythonClient:
    def __init__(self, server_name):
        self.server_name = server_name
        self.socket = QLocalSocket()
        self.stream = None
        self.connected = False

        # 连接信号槽
        self.socket.connected.connect(self.on_connected)
        self.socket.disconnected.connect(self.on_disconnected)
        self.socket.readyRead.connect(self.on_ready_read)
        self.socket.errorOccurred.connect(self.on_error_occurred)
    
    def connect_to_server(self):
        """连接到C++服务器"""
        if self.connected:
            print("Already connected to server")
            return True
            
        print(f"Connecting to server: {self.server_name}")
        self.socket.connectToServer(self.server_name)
        
        # 等待连接建立
        if self.socket.waitForConnected(3000):
            return True
        else:
            print(f"Failed to connect: {self.socket.errorString()}")
            return False
    
    def disconnect_from_server(self):
        """断开与服务器的连接"""
        if self.connected:
            self.socket.disconnectFromServer()
            if self.socket.state() != QLocalSocket.UnconnectedState:
                self.socket.waitForDisconnected(1000)
            self.connected = False
    
    def send_message(self, message):
        """发送消息到服务器"""
        if not self.connected:
            print("Not connected to server")
            return False
            
        block = QByteArray()
        stream = QDataStream(block, QIODevice.WriteOnly)
        stream.setVersion(QDataStream.Qt_5_15)
        stream.writeQString(message)
        
        bytes_written = self.socket.write(block)
        self.socket.flush()
        
        if bytes_written == -1:
            print(f"Failed to send message: {self.socket.errorString()}")
            return False
        else:
            print(f"Sent message: {message}")
            return True
    
    def on_connected(self):
        """连接建立时的回调"""
        print("Connected to C++ server successfully")
        self.connected = True
        self.stream = QDataStream(self.socket)
        self.stream.setVersion(QDataStream.Qt_5_15)
    
    def on_disconnected(self):
        """连接断开时的回调"""
        print("Disconnected from C++ server")
        self.connected = False
        self.stream = None
    
    def on_ready_read(self):
        """接收到数据时的回调"""
        if not self.stream:
            return
            
        while not self.stream.atEnd():
            try:
                message = self.stream.readQString()
                print(f"Received from C++ server: {message}")
                json_dict = json.loads(message)
                match json_dict["function"]:
                    case "testNP":
                        json_args = json_dict["args"]
                        arg1 = ast.literal_eval(json_args[0])
                        arg2 = ast.literal_eval(json_args[1])
                        res = cal.testNP(arg1, arg2)
                        self.send_message(res)
            except Exception as e:
                print(f"Error reading message: {e}")
    
    def on_error_occurred(self, socket_error):
        """发生错误时的回调"""
        print(f"Socket error: {self.socket.errorString()}")

def main():
    app = QCoreApplication(sys.argv)

    if len(sys.argv) > 1:
        server_name = sys.argv[1]
    else:
        return
    
    client = PythonClient(server_name)
    
    # 连接到服务器
    if not client.connect_to_server():
        sys.exit(1)
    
    # # 定时发送测试消息
    # message_count = 0
    # def send_test_message():
    #     nonlocal message_count
    #     message_count += 1
    #     message = f"Hello from Python client #{message_count}"
    #     client.send_message(message)
        
    #     # 发送5条消息后断开
    #     if message_count >= 5:
    #         QTimer.singleShot(1000, lambda: client.disconnect_from_server())
    #         QTimer.singleShot(2000, app.quit)
    
    # # 开始发送消息
    # QTimer.singleShot(1000, send_test_message)
    # timer = QTimer()
    # timer.timeout.connect(send_test_message)
    # timer.start(2000)  # 每2秒发送一次
    
    # print("Python client is running...")
    # print("Press Ctrl+C to exit")
    
    return app.exec_()

def testMain():
    testMessage = '{"function":"testNP","args":["[[1,2],[3,4]]","[[5,6],[7,8]]"]}'

    json_dict = json.loads(testMessage)
    match json_dict["function"]:
        case "testNP":
            json_args = json_dict["args"]
            arg1 = ast.literal_eval(json_args[0])
            arg2 = ast.literal_eval(json_args[1])
            cal.testNP(arg1, arg2)

if __name__ == "__main__":
    main()
    #testMain()