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

ctools/metrics.py

@@ -0,0 +1,131 @@
+import os
+import threading
+from enum import Enum
+
+from prometheus_client import Counter, Gauge, Summary, Histogram, start_http_server
+from ctools import call, cjson, sys_log, work_path
+
+log = sys_log.flog
+
+_metrics_port = 8889
+_persistent_json = {}
+_metrics_initial = {}
+_lock = threading.Lock()
+_metrics_persistent_path = os.path.join(work_path.get_user_work_path('metrics', True), 'persistent.json')
+
+# 认证中间件
+# @app.before_request
+# def check_authentication():
+#   auth = request.authorization
+#   if not auth or auth.username != USERNAME or auth.password != PASSWORD:
+#     return Response(
+#       "Unauthorized", 401, {"WWW-Authenticate": 'Basic realm="Login Required"'}
+#     )
+
+class MetricType(Enum):
+  COUNTER = 'counter'
+  GAUGE = 'gauge'
+  SUMMARY = 'summary'
+  HISTOGRAM = 'histogram'
+
+class Metric:
+  def __init__(self, metric_type: MetricType, metric_key: str, metric_labels: [], persistent: bool = False, buckets: [] = None, reset: bool = False, desc: str = ""):
+    self.metric_type = metric_type
+    self.metric_key = metric_key
+    self.metric_labels = metric_labels
+    self.buckets = buckets
+    self.metric = None
+    self.persistent = persistent
+    self.reset = reset
+    if metric_type == MetricType.COUNTER:
+      self.metric = Counter(metric_key, desc, metric_labels)
+    elif metric_type == MetricType.GAUGE:
+      self.metric = Gauge(metric_key, desc, metric_labels)
+    elif metric_type == MetricType.SUMMARY:
+      self.metric = Summary(metric_key, desc, metric_labels)
+    elif metric_type == MetricType.HISTOGRAM:
+      if buckets is None: raise Exception('histogram buckets can not empty')
+      self.metric = Histogram(metric_key, desc, metric_labels, buckets=self.buckets)
+    else:
+      raise Exception('metric type not found')
+    _metrics_initial[metric_key] = self
+
+@call.once
+def init(reset_persistent: bool = False):
+  if os.path.exists(_metrics_persistent_path) and not reset_persistent:
+    with open(_metrics_persistent_path, 'r') as persistent_file:
+      global _persistent_json
+      try:
+        content = persistent_file.readline()
+        log.info("persistent初始化: %s" % content)
+        _persistent_json = cjson.loads(content)
+      except Exception:
+        log.error('persistent.json is not valid json!!!!!')
+        _persistent_json = {}
+  _init_all_metrics()
+  _persistent_json = _persistent_json or {}
+  for key, item in _persistent_json.items():
+    metrics_key = key.split("-")[0]
+    if '_labels' in key or metrics_key not in _metrics_initial: continue
+    opt(metrics_key, _persistent_json[key + '_labels'], _persistent_json[key])
+  persistent_metrics()
+  start_http_server(port=_metrics_port)
+
+@call.schd(5, start_by_call=True)
+def persistent_metrics():
+  if _persistent_json and not _lock.locked():
+    log.info('begin persistent metrics to file...')
+    with open(_metrics_persistent_path, 'w') as persistent_file:
+      persistent_file.write(cjson.dumps(_persistent_json))
+      persistent_file.flush()
+
+def opt(metric_key: str, label_values: [], metric_value: int):
+  _lock.acquire(timeout=5)
+  try:
+    persistent_key = "%s-%s" % (metric_key, "_".join(map(str, label_values)))
+    metric_entity: Metric = _metrics_initial[metric_key]
+    if metric_entity.persistent:
+      if not metric_entity.reset and persistent_key in _persistent_json:
+        _persistent_json[persistent_key] += metric_value
+      else:
+        _persistent_json[persistent_key] = metric_value
+      _persistent_json[persistent_key + '_labels'] = label_values
+
+      if _persistent_json[persistent_key] < 0:
+        _persistent_json[persistent_key] = 0
+        metric_value = 0
+
+    if metric_entity.metric_type == MetricType.COUNTER or metric_entity.metric_type == MetricType.GAUGE:
+      if label_values is None or len(label_values) == 0:
+        if metric_entity.metric_type == MetricType.COUNTER and metric_entity.reset:
+          metric_entity.metric.labels('').reset()
+        if metric_entity.metric_type == MetricType.GAUGE and metric_entity.reset:
+          metric_entity.metric.labels('').set(0)
+        metric_entity.metric.labels('').inc(metric_value)
+      else:
+        if metric_entity.reset:
+          if metric_entity.metric_type == MetricType.COUNTER and metric_entity.reset:
+            metric_entity.metric.labels(*label_values).reset()
+          if metric_entity.metric_type == MetricType.GAUGE and metric_entity.reset:
+            metric_entity.metric.labels(*label_values).set(0)
+        metric_entity.metric.labels(*label_values).inc(metric_value)
+    else:
+      if label_values is None or len(label_values) == 0:
+        metric_entity.metric.observe(metric_value)
+      else:
+        metric_entity.metric.labels(*label_values).observe(metric_value)
+  except Exception as e:
+    log.error("添加指标信息异常: %s" % e)
+  _lock.release()
+
+def _init_all_metrics():
+  Metric(MetricType.GAUGE, 'gomyck', ['g_label1', 'g_label2'], persistent=True, reset=True)
+
+# if __name__ == '__main__':
+#   init()
+#   import random
+#   while True:
+#     opt('data_reported_time', ['123', '123'], random.randint(1, 10))
+#     opt('data_received_time', ['123', '123'], random.randint(1, 10))
+#     opt('data_insert_time',   ['123', '123'], random.randint(1, 10))
+#     time.sleep(1)

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)