gomyck-tools 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

ctools/mqtt_utils.py

@@ -0,0 +1,289 @@
+import time
+from enum import Enum
+from typing import Dict
+
+from ctools.dict_wrapper import DictWrapper as DictToObj
+from paho.mqtt import client as mqtt
+from paho.mqtt.enums import CallbackAPIVersion
+
+from ctools import sys_log, cjson, string_tools, sys_info, date_utils, sm_tools, thread_pool
+
+class MQTTEvent(Enum):
+
+  pass
+
+'''
+MQTT服务使用示例:
+
+mqtt_utils = MQTTUtils("192.168.3.100")
+mqtt_utils.connect(username="rpa", password="123")
+
+# 订阅
+mqtt_utils.subscribe("test/topic1", "test/topic2")
+
+# 异步发送
+msg = {"name": "测试消息"}
+mqtt_utils.publish_async(msg, event=MQTTEvent.END_TASK)
+
+# 同步发送
+mqtt_resp = mqtt_utils.publish_sync(msg, event=MQTTEvent.UPLOAD_PROCESS, timeout=60)
+status = mqtt_resp.status
+body = mqtt_resp.body
+print("%s, %s" % (status, body))
+'''
+
+log = sys_log.flog
+
+NO_LOG_EVENT = [MQTTEvent.HEARTBEAT]
+
+
+class MQTTRequest:
+
+  def __init__(self, **kwargs):
+    self.event: str = kwargs.get('event')
+    self.trace_id: str = kwargs.get('trace_id') if kwargs.get('trace_id') else string_tools.get_uuid()
+    self.client_id: str = kwargs.get('client_id')
+    self.time: str = kwargs.get('time') if kwargs.get('time') else date_utils.get_date_time()
+    self.body = kwargs.get('body')
+
+  def __str__(self):
+    res_str = ""
+    for k, v in self.__dict__.items():
+      res_str += "%s=%s," % (k, v)
+    return res_str[:-1]
+
+
+class MQTTResponse:
+
+  def __init__(self, **kwargs):
+    self.event: str = kwargs.get('event')
+    self.trace_id: str = kwargs.get('trace_id')
+    self.status: int = kwargs.get('status')
+    self.time: str = kwargs.get('time') if kwargs.get('time') else date_utils.get_date_time()
+    self.msg: str = kwargs.get('msg')
+    self.body = kwargs.get('body')
+
+  def __str__(self):
+    res_str = ""
+    for k, v in self.__dict__.items():
+      res_str += "%s=%s," % (k, v)
+    return res_str[:-1]
+
+
+class MQTTUtils:
+  def __init__(self, broker_address, port=1883, publish_topic=None, client_id=None, keepalive=60, clean_session=False,
+               userdata=None, protocol=mqtt.MQTTv311, message_handle=None, broker_encrypt_key=None):
+    self.publish_topic = publish_topic
+    self.broker_address = broker_address
+    self.port = port
+    self.client_id = client_id if client_id else sys_info.get_machine_code()
+    self.keepalive = keepalive
+    self.clean_session = clean_session
+    self.userdata = userdata
+    self.protocol = protocol
+    self.message_handle = message_handle
+    self.broker_encrypt_key = broker_encrypt_key
+
+    self.client = mqtt.Client(CallbackAPIVersion.VERSION2, client_id=self.client_id, clean_session=self.clean_session,
+                              userdata=self.userdata, protocol=self.protocol)
+    self.client.on_connect = self._on_connect
+    self.client.on_message = self._on_message_thread
+    self.client.on_disconnect = self._on_disconnect
+    if self.publish_topic:
+      will_msg = {
+        "event": "offline",
+        "client_id": self.client_id,
+        "trace_id": string_tools.get_uuid(),
+        "time": date_utils.get_date_time(),
+        "body": {"type": "will_msg"}
+      }
+      self.client.will_set(self.publish_topic, cjson.dumps(will_msg), 2, False)
+    self.connected = False
+    self._publish_trace_id = []
+    self._received_message: Dict[str: MQTTResponse] = {}
+
+  def _on_connect(self, client, userdata, flags, rc, properties):
+    if rc == 0:
+      log.info("mqtt服务连接成功")
+      self.connected = True
+    else:
+      log.info("mqtt服务连接失败, broker地址: %s:%s, rc: %s" % (self.broker_address, self.port, rc))
+
+  def _on_message_thread(self, client, userdata, message):
+    thread_pool.submit(self._on_message, client=client, userdata=userdata, message=message)
+
+  def _on_message(self, client, userdata, message):
+    # try:
+    if message.topic != self.publish_topic and message.payload:
+      mqtt_msg = cjson.loads(message.payload.decode())
+      trace_id = mqtt_msg.get('trace_id')
+      if trace_id in self._publish_trace_id:
+        mqtt_resp = MQTTResponse(**mqtt_msg)
+        self._received_message[trace_id] = mqtt_resp
+        self._publish_trace_id.remove(trace_id)
+      else:
+        mqtt_req = MQTTRequest(**mqtt_msg)
+
+        try:
+          if mqtt_req.event not in NO_LOG_EVENT:
+            log.debug("异步接收mqtt消息: %s" % str(mqtt_req))
+          if mqtt_req.body:
+            try:
+              mqtt_req.body = self.decrypt_body(mqtt_req.body)
+            except Exception:
+              if mqtt_req.event != MQTTEvent.HAND_SHARK:
+                log.error('解密消息失败: {}'.format(mqtt_req))
+                return
+          if isinstance(mqtt_req.body, dict):
+            mqtt_req.body = DictToObj(mqtt_req.body)
+        except Exception as e:
+          log.info("异步接收mqtt消息异常: %s" % e)
+        self.message_handle(mqtt_req, message.topic)
+    # except Exception as e:
+    #   log.error("接收mqtt消息异常: %s" % e)
+
+  def _on_disconnect(self, client, userdata, flags, rc, properties):
+    self.connected = False
+    log.info("mqtt服务已断开连接, rc: %s" % rc)
+
+  def encrypt_body(self, body):
+    if self.broker_encrypt_key:
+      try:
+        return sm_tools.encrypt_with_sm4(self.broker_encrypt_key, cjson.dumps(body))
+      except Exception:
+        return sm_tools.encrypt_with_sm4(self.broker_encrypt_key, body)
+
+  def decrypt_body(self, body):
+    if self.broker_encrypt_key:
+      try:
+        return cjson.loads(sm_tools.decrypt_with_sm4(self.broker_encrypt_key, body))
+      except Exception:
+        sm_tools.decrypt_with_sm4(self.broker_encrypt_key, body)
+
+  def connect(self, username=None, password=None, timeout=10):
+    if username and password:
+      self.client.username_pw_set(username, password)
+    self.client.connect_async(host=self.broker_address, port=self.port, keepalive=self.keepalive)
+    self.client.loop_start()
+
+    start_time = time.time()
+    while not self.connected and time.time() - start_time < timeout:
+      time.sleep(0.1)
+
+    if not self.connected:
+      log.info("mqtt服务连接超时, broker地址: %s:%s" % (self.broker_address, self.port))
+
+  def publish_resp(self, mqtt_resp: MQTTResponse, topic=None, encrypt=True, qos=2, retain=False):
+    """
+    发送mqtt响应信息
+    :param mqtt_resp: 响应信息, 使用 mqtt_service.init_resp('ok', req)
+    :param topic: 主题, 默认用订阅的主题
+    :param encrypt: 是否加密
+    :param qos: 消息质量
+    :param retain: 是否保留
+    """
+    topic = topic if topic else self.publish_topic
+    if self.connected:
+      if mqtt_resp:
+        try:
+          if encrypt and mqtt_resp.body:
+            mqtt_resp.body = self.encrypt_body(mqtt_resp.body)
+          mqtt_resp.client_id = self.client_id
+          mqtt_data = cjson.dumps(mqtt_resp)
+          self.client.publish(topic, mqtt_data, qos=qos, retain=retain)
+          log.debug("异步发送mqtt响应消息: topic: %s message: %s" % (topic, mqtt_data))
+        except Exception as e:
+          log.error('异步发送mqtt响应消息异常: %s' % e)
+    else:
+      log.info("异步发送mqtt响应-mqtt服务未连接, 无法发送消息")
+
+  def publish_async(self, message, event: MQTTEvent = None, encrypt=True, topic=None, qos=2, retain=False):
+    topic = topic if topic else self.publish_topic
+    if self.connected:
+      try:
+        if encrypt and message:
+          message = self.encrypt_body(message)
+
+        mqtt_req = MQTTRequest()
+        mqtt_req.client_id = self.client_id
+        mqtt_req.body = message
+        if event:
+          mqtt_req.event = event.value
+        mqtt_data = cjson.dumps(mqtt_req)
+        self.client.publish(topic, mqtt_data, qos=qos, retain=retain)
+        if event not in NO_LOG_EVENT:
+          log.debug("异步发送mqtt消息: topic: %s message: %s" % (topic, mqtt_data))
+      except Exception as e:
+        log.error('异步发送mqtt消息异常: %s' % e)
+    else:
+      log.info("异步发送mqtt消息-mqtt服务未连接, 无法发送消息")
+
+  def publish_sync(self, message, event: MQTTEvent, topic=None, encrypt=True,
+                   qos=2, retain=False, timeout: int = 15, send_time: str = None) -> MQTTResponse:
+    if not event: raise Exception("事件不能为空")
+    mqtt_resp = MQTTResponse()
+    mqtt_resp.status = 500
+    mqtt_resp.msg = "服务端未响应, 请联系管理员!"
+    topic = topic if topic else self.publish_topic
+    if self.connected:
+      try:
+        if encrypt and message:
+          message = self.encrypt_body(message)
+
+        mqtt_req = MQTTRequest()
+        mqtt_req.source = "client"
+        mqtt_req.client_id = self.client_id
+        mqtt_req.body = message
+        mqtt_req.time = send_time if send_time else mqtt_req.time
+        mqtt_req.event = event.value
+        mqtt_data = cjson.dumps(mqtt_req)
+        self._publish_trace_id.append(mqtt_req.trace_id)
+        self.client.publish(topic, mqtt_data, qos=qos, retain=retain)
+        if event not in NO_LOG_EVENT:
+          log.debug("同步发送mqtt消息: topic: %s message: %s" % (topic, mqtt_data))
+        is_timeout = False
+        start_time = time.time()
+        while True:
+          if mqtt_req.trace_id in self._received_message:
+            mqtt_resp = self._received_message.pop(mqtt_req.trace_id)
+            if mqtt_resp.body and encrypt:
+              mqtt_resp.body = self.decrypt_body(mqtt_resp.body)
+            break
+          if (time.time() - start_time) >= timeout:
+            is_timeout = True
+            break
+          time.sleep(0.5)
+        if not is_timeout:
+          if event not in NO_LOG_EVENT:
+            log.debug("同步接收mqtt消息: topic: %s message: %s" % (topic, mqtt_resp))
+        else:
+          log.info("同步发送mqtt消息, 等待返回信息超时: %s" % mqtt_req)
+      except Exception as e:
+        log.error('同步发送mqtt消息异常: %s-%s' % (event.value, e))
+    else:
+      log.info("同步接收mqtt消息-mqtt服务未连接, 无法发送消息")
+    return mqtt_resp
+
+  def subscribe(self, *topic, qos=0):
+    if self.connected:
+      if topic and len(topic) > 0:
+        for t in topic:
+          self.client.subscribe(t, qos=qos)
+          log.info("已订阅mqtt主题[%s]" % t)
+    else:
+      log.info("mqtt服务未连接, 无法订阅主题")
+
+  def unsubscribe(self, *topic):
+    if self.connected:
+      if topic and len(topic) > 0:
+        for t in topic:
+          self.client.unsubscribe(t)
+          log.info("已解除订阅mqtt主题[%s]" % t)
+    else:
+      log.info("mqtt服务未连接, 无法解除订阅主题")
+
+  def disconnect(self):
+    if self.connected:
+      self.client.disconnect()
+      self.client.loop_stop()
+      log.info("已关闭mqtt服务连接")

ctools/obj.py

@@ -0,0 +1,20 @@
+
+def isNull(param) -> bool:
+    if type(param) == str:
+        return param == ''
+    elif type(param) == list:
+        return len(param) == 0
+    elif type(param) == dict:
+        return len(param) == 0
+    elif type(param) == int:
+        return param == 0
+    elif type(param) == float:
+        return param == 0.0
+    elif type(param) == bool:
+        return param == False
+    else:
+        return param is None
+
+def isNotNull(param)  -> bool:
+    return not isNull(param)
+

ctools/pacth.py

@@ -0,0 +1,74 @@
+import os
+import shutil
+
+from sqlalchemy.sql import text
+
+from ctools import database
+
+
+class Patch:
+
+  def __init__(self, oldVersion, newVersion, pythonPath, playwrightPath, driverPath) -> None:
+    super().__init__()
+    self.oldV = oldVersion[len('V'):].replace('.', '').replace('-snapshot', '')
+    self.currentV = newVersion[len('V'):].replace('.', '').replace('-snapshot', '')
+    self.snapshot = '-snapshot' in newVersion or '-snapshot' in oldVersion
+    self.pythonPath = pythonPath
+    self.playwrightPath = playwrightPath
+    self.driverPath = driverPath
+    self.deleteSDK, self.deleteHPL, self.deleteDriver = False, False, False
+
+  def apply_patch(self):
+    patch_methods = [method for method in dir(self) if callable(getattr(self, method)) and method.startswith('patch_V')]
+    patch_methods.sort(key=lambda x: int(x[len('patch_V'):]))
+    max_method_name = patch_methods[-1]
+    exec_max_method = False
+    for method_name in patch_methods:
+      slVersion = method_name[len('patch_V'):]
+      if int(self.currentV) > int(slVersion) >= int(self.oldV):
+        if max_method_name == method_name: exec_max_method = True
+        method = getattr(self, method_name)
+        print('start exec patch {}'.format(method_name))
+        method()
+        print('patch {} update success'.format(method_name))
+    if self.snapshot and not exec_max_method:
+      print('start exec snapshot patch {}'.format(max_method_name))
+      method = getattr(self, max_method_name)
+      method()
+      print('snapshot patch {} update success'.format(max_method_name))
+
+  def patch_V220(self):
+    pass
+
+  def run_sqls(self, sqls):
+    with database.get_session() as s:
+      for sql in sqls.split(";"):
+        try:
+          s.execute(text(sql.strip()))
+          s.commit()
+        except Exception as e:
+          print('结构升级错误, 请检查!!! {}'.format(e.__cause__))
+
+  def remove_sdk(self):
+    if self.deleteSDK: return
+    try:
+      self.deleteSDK = True
+      if os.path.exists(self.pythonPath): shutil.rmtree(self.pythonPath)
+    except Exception as e:
+      print('删除SDK错误: {}'.format(e))
+
+  def remove_hpl(self):
+    if self.deleteHPL: return
+    try:
+      self.deleteHPL = True
+      if os.path.exists(self.playwrightPath): shutil.rmtree(self.playwrightPath)
+    except Exception as e:
+      print('删除HPL错误: {}'.format(e))
+
+  def remove_driver(self):
+    if self.deleteDriver: return
+    try:
+      self.deleteDriver = True
+      if os.path.exists(self.driverPath): shutil.rmtree(self.driverPath)
+    except Exception as e:
+      print('删除Driver错误: {}'.format(e))

ctools/plan_area_tools.py

@@ -0,0 +1,97 @@
+import tkinter as tk
+
+"""
+规划区域工具类, 按回车获取区域坐标
+image_path=screenshot_tools.screenshot()
+"""
+
+
+class PlanAreaTools:
+  def __init__(self):
+    self.root = tk.Tk()
+    self.root.overrideredirect(True)
+    self.root.attributes("-alpha", 0.1)
+    self.root.attributes('-topmost', 'true')
+    self.root.geometry("{0}x{1}+0+0".format(self.root.winfo_screenwidth(), self.root.winfo_screenheight()))
+    self.root.configure(bg="black")
+
+    self.canvas = tk.Canvas(self.root)
+
+    self.x, self.y = 0, 0
+    self.xstart, self.ystart = 0, 0
+    self.xend, self.yend = 0, 0
+    self.xcenter, self.ycenter = 0, 0
+
+    self.select_area = self.canvas.create_rectangle(0, 0, 0, 0, outline='red', width=0, dash=(4, 4))
+    self.center_offset = (0, 0)
+
+    self.pos_div = tk.Toplevel(self.root)
+    self.pos_div.overrideredirect(True)
+    self.pos_div.attributes('-topmost', 'true')
+    self.pos_div.configure(bg="grey")
+    self.pos_div.geometry("270x25")
+
+    self.pos_div_text = "POS: (%s, %s), Enter键-获取区域, Esc键-退出"
+    self.pos_label = tk.Label(self.pos_div, text=self.pos_div_text % (0, 0), bg="black", fg="white")
+    self.pos_label.pack(fill="both", expand=True)
+
+    self.root.bind('<Escape>', self.sys_out)  # 键盘Esc键->退出
+    self.root.bind('<Motion>', self.print_pos)
+    self.root.bind("<Button-1>", self.mouse_left_down)  # 鼠标左键点击->显示子窗口
+    self.root.bind("<B1-Motion>", self.mouse_left_move)  # 鼠标左键移动->改变子窗口大小
+    self.root.bind("<ButtonRelease-1>", self.mouse_left_up)  # 鼠标左键释放->记录最后光标的位置
+    self.root.bind("<Return>", self.save_area)  # 回车键->获取区域信息
+    self.root.focus()
+
+    self.area = [0, 0, 0, 0]
+
+  def start(self):
+    self.root.mainloop()
+
+  def print_pos(self, event):
+    self.x, self.y = event.widget.winfo_pointerxy()
+    self.pos_label.config(text=self.pos_div_text % (self.x, self.y))
+    self.pos_div.geometry(f"+{self.x + 10}+{self.y + 10}")
+
+  def mouse_left_down(self, event):
+    self.x, self.y = event.x, event.y
+    self.xstart, self.ystart = event.x, event.y
+    self.canvas.configure(height=1)
+    self.canvas.configure(width=1)
+    self.canvas.config(highlightthickness=0)
+    self.canvas.place(x=event.x, y=event.y)
+
+  def mouse_left_move(self, event):
+    self.x, self.y = event.x, event.y
+    self.xcenter = self.xstart + int((self.x-self.xstart)/2)-2
+    self.ycenter = self.ystart + int((self.y-self.ystart)/2)-2
+
+    self.pos_label.config(text=self.pos_div_text % (self.x, self.y))
+    self.pos_div.geometry(f"+{self.x + 10}+{self.y + 10}")
+
+    self.canvas.configure(height=event.y - self.ystart)
+    self.canvas.configure(width=event.x - self.xstart)
+    self.canvas.coords(self.select_area, 0, 0, event.x - self.xstart, event.y - self.ystart)
+
+  def mouse_left_up(self, event):
+    self.xend, self.yend = event.x, event.y
+
+  def save_area(self, event):
+    try:
+      self.area = [self.xstart, self.ystart, self.xend, self.yend]
+      self.canvas.delete(self.select_area)
+      self.canvas.place_forget()
+      self.sys_out()
+
+    except Exception:
+      pass
+
+  def sys_out(self, event=None):
+    self.pos_div.destroy()
+    self.root.destroy()
+
+
+def get_area():
+  pat = PlanAreaTools()
+  pat.start()
+  return tuple(pat.area)

ctools/process_pool.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/9/20 12:00'
+import os
+import time
+from concurrent.futures import ProcessPoolExecutor
+
+from ctools import call
+
+_process_pool: ProcessPoolExecutor = None
+
+@call.init
+def init():
+  global _process_pool
+  max_workers = min(32, os.cpu_count()) # 最多 32 个
+  _process_pool = ProcessPoolExecutor(max_workers=max_workers)
+
+def cb(f, callback):
+  exc = f.exception()
+  if exc:
+    if callback: callback(exc)
+    raise exc
+  else:
+    if callback: callback(f.result())
+
+def submit(func, *args, callback=None, **kwargs):
+  if _process_pool is None: raise Exception('process pool is not init')
+  future = _process_pool.submit(func, *args, **kwargs)
+  future.add_done_callback(lambda f: cb(f, callback))
+  time.sleep(0.01)
+  return future
+
+def shutdown(wait=True):
+  if _process_pool is None: raise Exception('process pool is not init')
+  _process_pool.shutdown(wait=wait)

ctools/pty_tools.py

@@ -0,0 +1,72 @@
+import _thread
+import queue
+import time
+
+# 伪终端交互
+
+from winpty import PtyProcess
+
+
+class Code:
+  SUCCESS = 200
+  FAIL = 201
+  PART = 206
+
+
+class PtyTools:
+  def __init__(self, cmd, prefix: str = ""):
+    self._process = PtyProcess.spawn(cmd)
+    self._read_queue = queue.Queue()
+    self._prefix = prefix
+    self._is_enable = False
+
+  def _read(self):
+    try:
+      while True:
+        msg = self._process.readline()
+        self._is_enable = True
+        if msg and self._prefix not in msg[:len(self._prefix)]:
+          self._read_queue.put(msg)
+        elif self._is_exit():
+          break
+    except Exception:
+      pass
+
+  def _is_exit(self):
+    return self._process.exitstatus is not None
+
+  def run(self):
+    _thread.start_new_thread(self._read, ())
+    while not self._is_enable:
+      time.sleep(1)
+
+  def read(self, end_str: str = None, is_async=False, timeout: int = 1):
+    code = Code.SUCCESS
+    content = ""
+    start_time = time.time()
+    while True:
+      if not self._read_queue.empty():
+        line = self._read_queue.get()
+        content += line
+        start_time = time.time()
+        if end_str is not None and end_str in line:
+          break
+        if is_async:
+          code = Code.PART
+          break
+      else:
+        if time.time() - start_time >= timeout:
+          break
+        if self._is_exit():
+          code = Code.FAIL
+          break
+      time.sleep(0.1)
+    return code, content
+
+  def send(self, msg, timeout: int = 0.5):
+    self._process.write('%s\r\n' % msg)
+    return self.read(timeout=timeout)
+
+  def close(self):
+    self._process.close(force=True)
+