# 定義回調(diào)函數(shù)
def callback(result):
    print('Callback function is called with result: ', result)

# 異步函數(shù)，需要傳入回調(diào)函數(shù)
def async_function(param1, param2, callback):
    # 進(jìn)行異步操作
    result = param1 + param2
    # 異步操作完成后調(diào)用回調(diào)函數(shù)
    callback(result)

# 調(diào)用異步函數(shù)，并傳入回調(diào)函數(shù)
async_function(1, 2, callback)

functools.partial(func, *args, **kwargs)

import functools

# 定義一個簡單的加法函數(shù)
def add(a, b):
    return a + b

# 固定 add 函數(shù)的第一個參數(shù)
add2 = functools.partial(add, 2)

# 調(diào)用 add2 函數(shù)
print(add2(3))  # 輸出：5

add3 = functools.partial(add, 3)
add4 = functools.partial(add, 4)
add5 = functools.partial(add, 5)

print(add3(2))  # 輸出：5
print(add4(2))  # 輸出：6
print(add5(2))  # 輸出：7

import json
import os
import socket
import threading
import time
import sys
import traceback

HOST = '127.0.0.1'  # 服務(wù)器IP地址
PORT = 8000  # 服務(wù)器端口號
BACKLOG = 5  # 服務(wù)器監(jiān)聽隊列大小，即最多同時接收多少個客戶端連接
RECONNECT_INTERVAL = 5  # 重連間隔，單位：秒


def start_server():
    print(os.getpid())
    while True:
        try:
            # 創(chuàng)建一個 TCP/IP socket 對象
            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            # 綁定服務(wù)器 IP 地址和端口號
            server_socket.bind((HOST, PORT))

            # 開始監(jiān)聽客戶端連接請求
            server_socket.listen(BACKLOG)
            print('服務(wù)器啟動，監(jiān)聽端口：%s' % PORT)

            while True:
                # 等待客戶端連接
                print('等待客戶端連接...')
                try:
                    client_socket, client_address = server_socket.accept()
                    threading.Thread(target=send_msg, args=(client_socket, client_address)).start()
                    # send_msg(client_socket, client_address)
                    print(f"Process {threading.current_thread()}: {threading.active_count()} threads")
                    print(f"Total threads: {threading.active_count()}")

                    print('新客戶端連接，地址：%s' % str(client_address))

                    # 讀取客戶端發(fā)送的數(shù)據(jù)
                    data = client_socket.recv(1024)
                    print('Received data:', data.decode())

                    # 向客戶端發(fā)送數(shù)據(jù)
                    message = 'Welcome to my server!'
                    client_socket.sendall(message.encode())

                except Exception as e:
                    print('客戶端連接異常，錯誤信息：%s' % e)

                finally:
                    # 關(guān)閉客戶端連接
                    client_socket.close()
                    print('客戶端連接已關(guān)閉')

        except Exception as e:
            print('服務(wù)器異常，錯誤信息：%s' % e)
            traceback.print_exc()

            # 關(guān)閉服務(wù)端 socket
            server_socket.close()
            print('{}s后嘗試重連服務(wù)器...'.format(RECONNECT_INTERVAL))
            time.sleep(RECONNECT_INTERVAL)


def send_msg(client, addr):
    try:
        while 1:
            time.sleep(1)
            jsonTemplate = {
                "Command": "FORWARD_ELEV_INFO",
                "DeviceId": "C0002T",
                "ElevId": 1,
            }
            msg2Elev = json.dumps(jsonTemplate).encode() + "\n".encode()
            client.sendto(msg2Elev, addr)
            print('send msg to client:{}:{}'.format(addr, msg2Elev))
    except Exception as e:
        print('send_msg:{}'.format(e))


if __name__ == '__main__':
    # 啟動服務(wù)器
    start_server()

import functools
import json
import socket
import threading
import time
import traceback


class TestClient(threading.Thread):

    def __init__(self, connectHost, connectPort, callbackFunc):
        threading.Thread.__init__(self, name="TestClient")
        self.host = connectHost
        self.port = connectPort
        self.callbackFunc = callbackFunc
        self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    def run(self):

        self.connect()
        while True:
            try:
                # 從socket中讀取數(shù)據(jù)
                # data = self.sck.recv(1024)
                # print(data)
                data = self.recv_msg(self.sck)
                if data is None:
                    time.sleep(1)
                    continue
                self.callbackFunc(data)
            except OSError:
                # An operation was attempted on something that is not a socket
                traceback.print_exc()
                time.sleep(5)
                # FIXME: if socket is broken, reconnect with the same sck does not work, so create an new one.
                self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                self.connect()

            except Exception as e:
                # TODO: if disconnected, connect it
                traceback.print_exc()
                time.sleep(5)
                self.connect()

    def recv_msg(self, sock):
        try:
            data = sock.recv(1024)
            print('recv data:{}'.format(data))
            return data
        except Exception as e:
            print('recv_msg:{}'.format(e))
            sock.close()
            time.sleep(0.5)

    def connect(self):

        while True:
            try:
                self.sck.connect((self.host, self.port))
                print("connected to Service {}:{}".format(self.host, self.port))
                break
            except ConnectionRefusedError:
                print("service refused or not started? Reconnecting to Service in 5s")
                time.sleep(5)

            except Exception as e:
                print("connect error type->{}".format(type(e)))
                traceback.print_exc()
                # FIXME: if other exception, not sure to restart action will work.
                time.sleep(5)


def callbackFunc(a, res):
    print(a)
    print('callback msg -- >', res)


if __name__ == '__main__':
    connectHost = '127.0.0.1'
    connectPort = 8000
    callbackFunc = callbackFunc

    elevClient = TestClient(connectHost, connectPort, functools.partial(callbackFunc, 'hello callback'))
    elevClient.start()