# The `HttpClient` class is a Python class that handles HTTP requests, sends commands to a server, # processes server responses, and calculates various results based on received data. from PySide6.QtCore import QObject, Signal, Slot, QTimer from datetime import datetime import random import gzip from io import BytesIO from Manager.history_manager import historyManager import json from config import * import requests import logging # 配置日志记录 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger('HttpClient') class HttpClient(QObject): reciveData = Signal(dict) def __init__(self, address, port, connection_name, psk=None): super().__init__() self.name = connection_name self.init = 1 self.file_name = "" self.device_name = "" self.address = address self.port = port self.tempIndex = 0 self.base_url = f"http://{address}:{port}/api" logger.info(f"HttpClient initialized with base URL: {self.base_url}") # 定时器 self.debug_timer = QTimer(self) self.debug_timer.setInterval(5000) self.debug_timer.timeout.connect(self.debug_info) if YSMODE: self.debug_timer.start() logger.info("Debug mode enabled") def debug_info(self): if self.tempIndex == 0: self.device_name = "scanner1" self.tempIndex = 1 elif self.tempIndex == 1: self.device_name = "scanner2" self.tempIndex = 0 self.reciveData.emit({ "device": self.device_name, "WtOSC": [random.uniform(0.80,0.82), 0.799, 0.819, 0.837, 0.83, 0.815, 0.812, 0.81], "WtINS": [random.uniform(10.498,10.520), 10.525, 10.512, 10.488, 10.485, 10.486, 10.471, 10.468], "WtISC": [0.973, 0.965, 0.94, 0.924, 0.935, 0.957, 0.968, 0.97], "WtALL": [12.271, 12.288, 12.271, 12.249, 12.25, 12.258, 12.25, 12.248], "AngOSC": [0, 90, 346.656], "AngINS": [270, 0, 253.233], "AngISC": [90, 315, 144.457], "AngALL": [270, 0, 226.029], "DmCORE": [random.uniform(14,14.3), 14.2, 14.1], "DmALL": [random.uniform(37,37.2), 37.1, 37.2], "EccentricityINS": random.uniform(0.30, 0.60), "EccentricityOSC": 4.540023894862595, "EccentricityISC": 5.035971223021576, "Volatility": [0.021, 0.021, 0.028], "EllipticityDmALL": -0.0, "EllipticityDmCORE": -0.0, "AvgALL": 12.260625000000001, "AvgISC": 0.954, "AvgOSC": 0.81525, "AvgINS": 10.491625, "MinALL": 12.248, "MinISC": 0.924, "MinOSC": 0.799, "MinINS": 10.468, "ConcentricityALL": 99.83697424193022, "ConcentricityISC": 97.4169741697417, "ConcentricityOSC": 97.67726161369193, "ConcentricityINS": 99.72848092221216, "EccentricALL": 0.020000000000000462, "EccentricISC": 0.024499999999999966, "EccentricOSC": 0.01899999999999996, "EccentricINS": 0.028500000000000192, "EccentricityALL": 0.32552083333334086,"EdgesA": [41.53, 42.66, 54.93, 56.28, 75.88, 76.58, 86.97, 88.19], "EdgesB": [39.36, 40.58, 52.69, 53.92, 73.64, 74.23, 84.77, 86.01]}) # self.reciveData.emit({ # "device": self.device_name, # "WtOSC": [0.83, 0.86, 0.84, 0.81, 0.88, 0.92, 0.87, 0.79], # "WtISC": [0.72, 0.76, 1.03, 0.96, 1.05, 0.84, 0.77, 0.89], # "WtINS": [5.96, 6.57, 11.33, 13.54, 11.27, 6.47, 5.88, 7.62], # "WtALL": [7.50, 8.20, 13.20, 15.32, 13.21, 8.22, 7.52, 9.30], # "AngOSC": [303.75, 225.00, 21.88], # "AngINS": [202.50, 135.00, 274.23], # "AngISC": [247.50, 78.75, 301.21], # "AngALL": [247.50, 135.00, 286.10], # "DmCORE": [16.69, 14.54, 18.85], # "DmALL": [37.21, 39.16, 35.27], # "DmCOREDeviation": 1, # "DmALLDeviation": 2, # "AvgINS": 8.82, # "AvgOSC": 0.95, # "AvgISC": 0.88, # "AvgALL": 9.63, # "MinISC": 0.95, # "MinOSC": 0.81, # "MinINS": 5.88, # "MinALL": 7.50, # "EccentricINS": 0.95, # "EccentricOSC": 2.03, # "EccentricISC": 3.22, # "EccentricALL": 8.82, # "EccentricityINS": 16.003, # "EccentricityOSC": 21.126, # "EccentricityISC": 43.283, # "EccentricityALL": 43.283, # "ConcentricityALL" : 21.25, # "ConcentricityINS" : 21.25, # "ConcentricityOSC" : 11.63, # "ConcentricityISC" : 6.53, # "ConcentricityDeviationALL": 21.25, # "ConcentricityDeviationINS": 21.25, # "ConcentricityDeviationOSC": 11.63, # "ConcentricityDeviationISC": 6.53, # "EllipticityDmCORE": 6.51, # "EllipticityDmALL": 9.68, # "Volatility": [0.290, 0.088, 0.314], # "EdgesA": [41.53, 42.66, 54.93, 56.28, 75.88, 76.58, 86.97, 88.19], # "EdgesB": [39.36, 40.58, 52.69, 53.92, 73.64, 74.23, 84.77, 86.01] # }) def start_handshake(self): # HTTP客户端不需要握手,可以直接发送请求 logger.info(f"{self.name}: HTTP client ready to send requests to {self.address}:{self.port}") def check_server_status(self): """检查服务器状态""" try: url = f"{self.base_url}/status" response = requests.get(url, timeout=5) if response.status_code == 200: return response.json() else: logger.error(f"Failed to get server status, status code: {response.status_code}") return None except Exception as e: logger.error(f"Error checking server status: {e}") return None @Slot() def handle_timeout(self): # HTTP客户端不需要重连,重试请求即可 logger.info(f"{self.name}: HTTP request timeout, ready to retry") @Slot() def udp_socket_connected(self): # 兼容原有接口,HTTP客户端不需要UDP连接 pass @Slot() def readyRead(self): # 兼容原有接口,HTTP客户端不需要监听接收数据 pass def send_command(self, command, params=None): """发送命令到服务器""" try: url = f"{self.base_url}/command" data = {"command": command} if params: data.update(params) response = requests.post(url, json=data, timeout=10) if response.status_code == 200: logger.info(f"Command '{command}' sent successfully") return response.json() else: logger.error(f"Failed to send command '{command}', status code: {response.status_code}") return None except Exception as e: logger.error(f"Error sending command '{command}': {e}") return None @Slot() def handshake_timeout(self): # HTTP客户端不需要处理握手超时 pass @Slot(bytearray) def write_data(self, data): """发送二进制数据到服务器""" try: url = f"{self.base_url}/data" files = {'file': ('binary_data', data, 'application/octet-stream')} response = requests.post(url, files=files, timeout=10) if response.status_code == 200: logger.info('Data sent successfully') result = response.json() if result: self.reciveData.emit(self.calResult(json.dumps(result))) return True else: logger.error(f"Failed to send data, status code: {response.status_code}") return False except Exception as e: logger.error(f"Error sending data: {e}") return False def compress_file_with_params(self, file_content): compressed_data = None try: # 使用BytesIO来创建一个可写的文件对象 compressed_file = BytesIO() with gzip.GzipFile(fileobj=compressed_file, mode='wb') as gzf: gzf.write(file_content) # 读取压缩后的文件内容 compressed_data = compressed_file.getvalue() return compressed_data except Exception as e: logger.error(f'Error compressing file: {e}') return None @Slot(int, bytearray,str, int) def start_cal(self, motor_index, file_content, direction, row_count): """开始计算,通过HTTP发送文件数据""" logger.info(f"Starting calculation with motor_index: {motor_index}, direction: {direction}") if direction == "": return direction_value = 0 if direction == "UP": direction_value = 1 elif direction == "DOWN": direction_value = 2 current_time = datetime.now() compress_file_content = self.compress_file_with_params(file_content) if not compress_file_content: logger.error("Failed to compress file content") return self.device_name = f"scanner{motor_index}" self.file_name = f'{current_time.strftime("%Y-%m-%d_%H_%M_%S_%f")[:-3]}_direction_{direction_value}_device{motor_index}.csv' try: url = f"{self.base_url}/data" # 准备表单数据 form_data = { "init": str(self.init), "device_id": str(motor_index), "device_name": DEVICENAME, "version": "2", "offset": "0", "scale": "1", "file_type": "raw", "compress": "gz", "row_count": str(row_count), "direction": direction } # 准备文件数据 files = { 'file': (f'{self.file_name}.gz', compress_file_content, 'application/gzip') } self.init = 0 logger.info(f"Sending file: {self.file_name}.gz with size: {len(compress_file_content)} bytes") # 发送HTTP POST请求 response = requests.post(url, data=form_data, files=files, timeout=30) if response.status_code == 200: logger.info("Calculation request sent successfully") try: result = response.json() if result: # 添加设备名称到结果中 result['device'] = self.device_name # 计算额外的结果数据 processed_result = self.calResult(json.dumps(result)) self.reciveData.emit(processed_result) except json.JSONDecodeError: logger.error("Failed to parse server response as JSON") else: logger.error(f"Failed to send calculation request, status code: {response.status_code}") logger.error(f"Response content: {response.text}") except Exception as e: logger.error(f"Error sending calculation request: {e}") @Slot() def set_init(self): self.init = 1 logger.info(f"=====set init==== {self.init}") def calResult(self, r_str): """处理服务器返回的计算结果""" try: robj = json.loads(r_str) # 安全地获取结果中的数据,如果不存在则使用默认空列表 DmALL = robj.get("DmALL", []) DmCORE = robj.get("DmCORE", []) WtOSC = robj.get("WtOSC", []) WtINS = robj.get("WtINS", []) WtISC = robj.get("WtISC", []) WtALL = robj.get("WtALL", []) # 设置设备名称 robj["device"] = self.device_name # 计算椭圆度 if len(DmALL) >= 3: robj["EllipticityDmALL"] = 2*abs(DmALL[1]-DmALL[2])/(DmALL[1] + DmALL[2]) if (DmALL[1] + DmALL[2]) != 0 else 0 else: robj["EllipticityDmALL"] = 0 if len(DmCORE) >= 3: robj["EllipticityDmCORE"] = 2*abs(DmCORE[1]-DmCORE[2])/(DmCORE[1] + DmCORE[2]) if (DmCORE[1] + DmCORE[2]) != 0 else 0 else: robj["EllipticityDmCORE"] = 0 # 计算平均值 robj["AvgALL"] = self.avg(WtALL) robj["AvgISC"] = self.avg(WtISC) robj["AvgOSC"] = self.avg(WtOSC) robj["AvgINS"] = self.avg(WtINS) # 计算最小值 if WtALL: robj["MinALL"] = min(WtALL) robj["ConcentricityALL"] = 200*min(WtALL)/(min(WtALL)+max(WtALL)) if (min(WtALL)+max(WtALL)) != 0 else 0 robj["EccentricALL"] = (max(WtALL) - min(WtALL))/2 robj["EccentricityALL"] = (max(WtALL) - min(WtALL))*100/max(WtALL) if max(WtALL) != 0 else 0 else: robj["MinALL"] = 0 robj["ConcentricityALL"] = 0 robj["EccentricALL"] = 0 robj["EccentricityALL"] = 0 if WtISC: robj["MinISC"] = min(WtISC) robj["ConcentricityISC"] = 200*min(WtISC)/(min(WtISC)+max(WtISC)) if (min(WtISC)+max(WtISC)) != 0 else 0 robj["EccentricISC"] = (max(WtISC) - min(WtISC))/2 robj["EccentricityISC"] = (max(WtISC) - min(WtISC))*100/max(WtISC) if max(WtISC) != 0 else 0 else: robj["MinISC"] = 0 robj["ConcentricityISC"] = 0 robj["EccentricISC"] = 0 robj["EccentricityISC"] = 0 if WtOSC: robj["MinOSC"] = min(WtOSC) robj["ConcentricityOSC"] = 200*min(WtOSC)/(min(WtOSC)+max(WtOSC)) if (min(WtOSC)+max(WtOSC)) != 0 else 0 robj["EccentricOSC"] = (max(WtOSC) - min(WtOSC))/2 robj["EccentricityOSC"] = (max(WtOSC) - min(WtOSC))*100/max(WtOSC) if max(WtOSC) != 0 else 0 else: robj["MinOSC"] = 0 robj["ConcentricityOSC"] = 0 robj["EccentricOSC"] = 0 robj["EccentricityOSC"] = 0 if WtINS: robj["MinINS"] = min(WtINS) robj["ConcentricityINS"] = 200*min(WtINS)/(min(WtINS)+max(WtINS)) if (min(WtINS)+max(WtINS)) != 0 else 0 robj["EccentricINS"] = (max(WtINS) - min(WtINS))/2 robj["EccentricityINS"] = (max(WtINS) - min(WtINS))*100/max(WtINS) if max(WtINS) != 0 else 0 else: robj["MinINS"] = 0 robj["ConcentricityINS"] = 0 robj["EccentricINS"] = 0 robj["EccentricityINS"] = 0 # 保存到历史记录 try: historyManager.create(robj) except Exception as hist_error: logger.error(f"Error saving to history: {hist_error}") return robj except Exception as e: logger.error(f"Error processing calculation result: {e}") return {} def avg(self, data): """计算平均值""" if len(data) == 0: return 0 if len(data) == 1: return data[0] try: mean_value = sum(data) / len(data) return mean_value except TypeError: logger.error("Error calculating average: data contains non-numeric values") return 0 @Slot(object) def psk_required(self, auth): # HTTP客户端不需要PSK认证 pass # 为了保持向后兼容性,可以继续使用原类名 CalcHttpClient = HttpClient