gomyck-tools 1.0.0__py3-none-any.whl → 1.4.7__py3-none-any.whl

ctools/geo/coord_trans.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+import math
+
+x_pi = 3.14159265358979324 * 3000.0 / 180.0
+pi = 3.1415926535897932384626  # π
+a = 6378245.0  # 长半轴
+ee = 0.00669342162296594323  # 偏心率平方
+
+
+def gcj02_to_bd09(lng, lat):
+  """
+  火星坐标系(GCJ-02)转百度坐标系(BD-09)
+  谷歌、高德——>百度
+  :param lng:火星坐标经度
+  :param lat:火星坐标纬度
+  :return:
+  """
+  z = math.sqrt(lng * lng + lat * lat) + 0.00002 * math.sin(lat * x_pi)
+  theta = math.atan2(lat, lng) + 0.000003 * math.cos(lng * x_pi)
+  bd_lng = z * math.cos(theta) + 0.0065
+  bd_lat = z * math.sin(theta) + 0.006
+  return [bd_lng, bd_lat]
+
+
+def bd09_to_gcj02(bd_lon, bd_lat):
+  """
+  百度坐标系(BD-09)转火星坐标系(GCJ-02)
+  百度——>谷歌、高德
+  :param bd_lat:百度坐标纬度
+  :param bd_lon:百度坐标经度
+  :return:转换后的坐标列表形式
+  """
+  x = bd_lon - 0.0065
+  y = bd_lat - 0.006
+  z = math.sqrt(x * x + y * y) - 0.00002 * math.sin(y * x_pi)
+  theta = math.atan2(y, x) - 0.000003 * math.cos(x * x_pi)
+  gg_lng = z * math.cos(theta)
+  gg_lat = z * math.sin(theta)
+  return [gg_lng, gg_lat]
+
+
+def wgs84_to_gcj02(lng, lat):
+  """
+  WGS84转GCJ02(火星坐标系)
+  :param lng:WGS84坐标系的经度
+  :param lat:WGS84坐标系的纬度
+  :return:
+  """
+  if out_of_china(lng, lat):  # 判断是否在国内
+    return [lng, lat]
+  dlat = _transformlat(lng - 105.0, lat - 35.0)
+  dlng = _transformlng(lng - 105.0, lat - 35.0)
+  radlat = lat / 180.0 * pi
+  magic = math.sin(radlat)
+  magic = 1 - ee * magic * magic
+  sqrtmagic = math.sqrt(magic)
+  dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * pi)
+  dlng = (dlng * 180.0) / (a / sqrtmagic * math.cos(radlat) * pi)
+  mglat = lat + dlat
+  mglng = lng + dlng
+  return [mglng, mglat]
+
+
+def gcj02_to_wgs84(lng, lat):
+  """
+  GCJ02(火星坐标系)转GPS84
+  :param lng:火星坐标系的经度
+  :param lat:火星坐标系纬度
+  :return:
+  """
+  if out_of_china(lng, lat):
+    return [lng, lat]
+  dlat = _transformlat(lng - 105.0, lat - 35.0)
+  dlng = _transformlng(lng - 105.0, lat - 35.0)
+  radlat = lat / 180.0 * pi
+  magic = math.sin(radlat)
+  magic = 1 - ee * magic * magic
+  sqrtmagic = math.sqrt(magic)
+  dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * pi)
+  dlng = (dlng * 180.0) / (a / sqrtmagic * math.cos(radlat) * pi)
+  mglat = lat + dlat
+  mglng = lng + dlng
+  return [lng * 2 - mglng, lat * 2 - mglat]
+
+
+def bd09_to_wgs84(bd_lon, bd_lat):
+  lon, lat = bd09_to_gcj02(bd_lon, bd_lat)
+  return gcj02_to_wgs84(lon, lat)
+
+
+def wgs84_to_bd09(lon, lat):
+  lon, lat = wgs84_to_gcj02(lon, lat)
+  return gcj02_to_bd09(lon, lat)
+
+
+def _transformlat(lng, lat):
+  ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + \
+        0.1 * lng * lat + 0.2 * math.sqrt(math.fabs(lng))
+  ret += (20.0 * math.sin(6.0 * lng * pi) + 20.0 *
+          math.sin(2.0 * lng * pi)) * 2.0 / 3.0
+  ret += (20.0 * math.sin(lat * pi) + 40.0 *
+          math.sin(lat / 3.0 * pi)) * 2.0 / 3.0
+  ret += (160.0 * math.sin(lat / 12.0 * pi) + 320 *
+          math.sin(lat * pi / 30.0)) * 2.0 / 3.0
+  return ret
+
+
+def _transformlng(lng, lat):
+  ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + \
+        0.1 * lng * lat + 0.1 * math.sqrt(math.fabs(lng))
+  ret += (20.0 * math.sin(6.0 * lng * pi) + 20.0 *
+          math.sin(2.0 * lng * pi)) * 2.0 / 3.0
+  ret += (20.0 * math.sin(lng * pi) + 40.0 *
+          math.sin(lng / 3.0 * pi)) * 2.0 / 3.0
+  ret += (150.0 * math.sin(lng / 12.0 * pi) + 300.0 *
+          math.sin(lng / 30.0 * pi)) * 2.0 / 3.0
+  return ret
+
+
+def out_of_china(lng, lat):
+  """
+  判断是否在国内，不在国内不做偏移
+  :param lng:
+  :param lat:
+  :return:
+  """
+  return not (lng > 73.66 and lng < 135.05 and lat > 3.86 and lat < 53.55)

ctools/geo/douglas_rarefy.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/9/19 14:02'
+
+import math
+
+from jsonpath_ng import parser
+
+from ctools import cjson
+from ctools.sys_log import flog as log
+
+"""
+douglas_rarefy.DouglasRarefy(res, level=3).sparse_points()
+"""
+
+
+class THIN_LEVEL:
+  L1 = 0.00001
+  L2 = 0.00003
+  L3 = 0.00009
+  L4 = 0.0002
+  L5 = 0.0004
+  L6 = 0.0007
+  L7 = 0.0011
+  L8 = 0.0017
+  L9 = 0.0022
+
+
+class Point:
+  def __init__(self, lng, lat, origin_data):
+    self.lng = lng
+    self.lat = lat
+    self.origin_data = origin_data
+
+
+def _get_line_by_point(xy1, xy2):
+  """
+  根据两个点求直线方程 ax + by + c = 0
+  :param xy1: 点1, 例如 {'lat': 1, 'lng': 1}
+  :param xy2: 点2, 例如 {'lat': 2, 'lng': 2}
+  :return: 直线方程的三个参数 [a, b, c]
+  """
+  x1 = xy1.lng
+  y1 = xy1.lat
+  x2 = xy2.lng
+  y2 = xy2.lat
+  a = y2 - y1
+  b = x1 - x2
+  c = (y1 - y2) * x1 - y1 * (x1 - x2)
+  return [a, b, c]
+
+
+def _get_distance_from_point_to_line(a, b, c, xy):
+  """
+  点到直线的距离，直线方程为 ax + by + c = 0
+  :param a: 直线参数a
+  :param b: 直线参数b
+  :param c: 直线参数c
+  :param xy: 点坐标，例如 {'lat': 2, 'lng': 2}
+  :return: 距离
+  """
+  x = xy.lng
+  y = xy.lat
+  return abs((a * x + b * y + c) / math.sqrt(a * a + b * b))
+
+
+class DouglasRarefy:
+  """
+  DouglasRarefy Use Guide:
+    points must be arrays, element can be dict or arrays, when element is arrays, index 0 must be lng, index 1 must be lat, and element can be use max column num is 2 (lng, lat) in ret_tpl
+    level default is L2, this level can be hold most of the points detail
+    ret_tpl is the result tpl, can be arrays and json or some can be json loads, exp: [{lng}, {lat}] OR {{"lng": {lng}, "lat": {lat}}}
+  """
+
+  def __init__(self, points: [], level=THIN_LEVEL.L2, ret_tpl=None, get_lng=None, get_lat=None):
+    if not isinstance(points, list): raise Exception('points must be list obj !!')
+    if len(points) < 3: raise Exception('points length must be gt 2 !!')
+    self.points = points
+    self.threshold = THIN_LEVEL.L2 if level is None else (getattr(THIN_LEVEL, "L{}".format(int(level))) if int(level) >= 1 else level)
+    log.debug("threshold is: {}".format(self.threshold))
+    self.is_json = isinstance(points[0], dict)
+    self.get_lng = get_lng
+    self.get_lat = get_lat
+    if self.is_json:
+      if not self.get_lng: self.get_lng = '$.lng'
+      if not self.get_lat: self.get_lat = '$.lat'
+    else:
+      if not self.get_lng: self.get_lng = '$.[0]'
+      if not self.get_lat: self.get_lat = '$.[1]'
+    log.debug("get_lng is: {}, get_lat is: {}".format(self.get_lng, self.get_lat))
+    self.lng_parser = parser.parse(self.get_lng)
+    self.lat_parser = parser.parse(self.get_lat)
+    log.debug("is_json is: {}".format(self.is_json))
+    self.ret_tpl = ret_tpl
+    log.debug("ret_tpl is: {}".format(self.ret_tpl))
+    self.data = [Point(self.lng_parser.find(p)[0].value, self.lat_parser.find(p)[0].value, p) for p in self.points]
+
+  def _sparse_points(self, points):
+    """
+    点位压缩
+    :return: 稀疏后的点集
+    """
+    if len(points) < 3:
+      if not self.ret_tpl:
+        return [points[0].origin_data, points[-1].origin_data]
+      else:
+        if self.is_json:
+          return [cjson.loads(self.ret_tpl.format(**points[0].origin_data)), cjson.loads(self.ret_tpl.format(**points[-1].origin_data))]
+        else:
+          return [cjson.loads(self.ret_tpl.format(lng=points[0].lng, lat=points[0].lat)), cjson.loads(self.ret_tpl.format(lng=points[-1].lng, lat=points[-1].lat))]
+
+    xy_first = points[0]  # 第一个点
+    xy_end = points[-1]  # 最后一个点
+    a, b, c = _get_line_by_point(xy_first, xy_end)  # 获取直线方程的 a, b, c 值
+    d_max = 0  # 记录点到直线的最大距离
+    split = 0  # 分割位置
+    for i in range(1, len(points) - 1):
+      d = _get_distance_from_point_to_line(a, b, c, points[i])
+      if d > d_max:
+        split = i
+        d_max = d
+    if d_max > self.threshold:
+      # 如果存在点到首位点连成直线的距离大于 max_distance 的, 即需要再次划分
+      child_left = self._sparse_points(points[:split + 1])  # 递归处理左边部分
+      child_right = self._sparse_points(points[split:])  # 递归处理右边部分
+      # 合并结果，避免重复
+      return child_left + child_right[1:]
+    else:
+      if not self.ret_tpl:
+        return [points[0].origin_data, points[-1].origin_data]
+      else:
+        if self.is_json:
+          return [cjson.loads(self.ret_tpl.format(**points[0].origin_data)), cjson.loads(self.ret_tpl.format(**points[-1].origin_data))]
+        else:
+          return [cjson.loads(self.ret_tpl.format(lng=points[0].lng, lat=points[0].lat)), cjson.loads(self.ret_tpl.format(lng=points[-1].lng, lat=points[-1].lat))]
+
+  def sparse_points(self):
+    return self._sparse_points(self.data)

ctools/metrics.py

@@ -2,22 +2,28 @@ import os
 import threading
 from enum import Enum
 
-from prometheus_client import Counter, Gauge, Summary, Histogram
+from prometheus_client import Counter, Gauge, Summary, Histogram, start_http_server
 
-from business.common.constant import MetricKey
-from ctools import call, cjson, sys_log
-from ctools.application import Server
+from ctools import call, cjson, sys_log, path_info
 
 log = sys_log.flog
 
-metrics = {}
+_metrics_port = 8889
+_persistent_json = {}
 _metrics_initial = {}
-persistent_json = {}
-temp_metrics_json = {}
-is_metrics_init: bool = True
 _lock = threading.Lock()
+_metrics_persistent_path = os.path.join(path_info.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'
@@ -26,8 +32,7 @@ class MetricType(Enum):
 
 
 class Metric:
-  def __init__(self, metric_type: MetricType, metric_key: str, metric_labels: [],
-               persistent: bool = False, buckets: [] = None, reset: bool = False, desc: str = ""):
+  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
@@ -50,34 +55,33 @@ class Metric:
 
 
 @call.once
-def init():
-  global is_metrics_init
-  global temp_metrics_json
-  persistent_path = os.path.join(Server.indicatorsPath, 'persistent.json')
-  if os.path.exists(persistent_path):
-    with open(persistent_path, 'r') as persistent_file:
-      global persistent_json
+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)
+        log.info("persistent初始化: %s" % content)
+        _persistent_json = cjson.loads(content)
       except Exception:
         log.error('persistent.json is not valid json!!!!!')
-        persistent_json = {}
+        _persistent_json = {}
   _init_all_metrics()
-  for key, item in persistent_json.items():
+  _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])
+    opt(metrics_key, _persistent_json[key + '_labels'], _persistent_json[key])
   persistent_metrics()
-  is_metrics_init = False
+  start_http_server(port=_metrics_port)
 
 
-@call.schd(60, start_by_call=True)
+@call.schd(5, start_by_call=True)
 def persistent_metrics():
-  if persistent_json and not _lock.locked():
-    with open(os.path.join(Server.indicatorsPath, 'persistent.json'), 'w') as persistent_file:
-      persistent_file.write(cjson.dumps(persistent_json))
+  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()
 
 
@@ -85,34 +89,31 @@ 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.get(persistent_key)
-    if not metric_entity:
-      metric_entity = metrics[persistent_key] = _metrics_initial[metric_key]
-
+    metric_entity: Metric = _metrics_initial[metric_key]
     if metric_entity.persistent:
-      if not is_metrics_init and not metric_entity.reset and persistent_key in persistent_json:
-        persistent_json[persistent_key] += metric_value
+      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
+        _persistent_json[persistent_key] = metric_value
+      _persistent_json[persistent_key + '_labels'] = label_values
 
-      if persistent_json[persistent_key] < 0:
-        persistent_json[persistent_key] = 0
+      if _persistent_json[persistent_key] < 0:
+        _persistent_json[persistent_key] = 0
         metric_value = 0
 
-    temp_metrics_json[persistent_key] = metric_value
-
     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.reset()
-        metric_entity.metric.inc(metric_value)
+          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:
-          try:
-            metric_entity.metric.remove(*label_values)
-          except Exception:
-            pass
+          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:
@@ -125,21 +126,13 @@ def opt(metric_key: str, label_values: [], metric_value: int):
 
 
 def _init_all_metrics():
-  Metric(MetricType.COUNTER, 'demo123123', ['asdasd', 'sdfsdf'], persistent=True)
-  Metric(MetricType.GAUGE, MetricKey.ASSETS_TPL_COUNT.value, [], persistent=True, desc="模版数量")
-  Metric(MetricType.GAUGE, MetricKey.ASSETS_FLOW_COUNT.value, [], persistent=True, desc="流程数量")
-  Metric(MetricType.GAUGE, MetricKey.ASSETS_SCHEDULE_COUNT.value, [], persistent=True, desc="调度任务数量")
-
-  Metric(MetricType.COUNTER, MetricKey.CLIENT_STATUS_RUNNING_STATE.value, [], reset=True, desc="运行状态")
-  Metric(MetricType.COUNTER, MetricKey.CLIENT_STATUS_AUTHORIZED_DAYS.value, [], reset=True, desc="已授权天数")
-  Metric(MetricType.COUNTER, MetricKey.CLIENT_STATUS_PROGRESS.value, ['process_id'], reset=True, desc="流程运行进度[0-100]")
-
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_EXEC_COUNT.value, ['process_id'], persistent=True, desc="流程执行次数")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_HOURS.value, ['process_id'], persistent=True, desc="全部流程工作时长")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_HOURS_SINGLE.value, ['process_id'], reset=True, desc="单次流程工作时长")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_COLLECT_DATA_TOTAL.value, ['process_id'], persistent=True, desc="全部流程采集数据总量")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_COLLECT_DATA_TOTAL_SINGLE.value, ['process_id'], reset=True, desc="单次流程采集数据总量")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_SEND_DATA_TOTAL.value, ['process_id'], persistent=True, desc="全部流程发送数据总量")
-  Metric(MetricType.COUNTER, MetricKey.WORKLOAD_PROCESS_SEND_DATA_TOTAL_SINGLE.value, ['process_id'], reset=True, desc="单次流程发送数据总量")
-
-  Metric(MetricType.COUNTER, MetricKey.ERROR_SCHEDULE_COUNT.value, ['process_id'], persistent=True, desc="出错任务数")
+  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/office/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/6/11 09:37'

ctools/office/cword.py

@@ -0,0 +1,30 @@
+# from docxtpl import DocxTemplate
+#
+# # tpl = DocxTemplate('/Users/haoyang/Desktop/xxx.docx')
+# tpl = DocxTemplate('/Users/haoyang/Desktop/123.doc')
+#
+# # 设置好各标签需要填写的内容
+# context = {'xxxx': '计算机科学与技术', 'cccc': '2022050513'}
+# # 将标签内容填入模板中
+# tpl.render(context)
+# # 保存
+# tpl.save('/Users/haoyang/Desktop/new_test2.docx')
+
+from docx import Document
+
+
+def merge_word_files(input_files: [], output_file: str):
+  merged_doc = Document()
+  for file in input_files:
+    doc = Document(file)
+    for element in doc.element.body:
+      merged_doc.element.body.append(element)
+  merged_doc.save(output_file)
+
+
+def read_word_file(input_file: str):
+  doc = Document(input_file)
+  text = []
+  for paragraph in doc.paragraphs:
+    text.append(paragraph.text)
+  return "\n".join(text)

ctools/{word_fill.py → office/word_fill.py}

@@ -16,7 +16,7 @@ from xlsxtpl import writerx as xlsx_writerx
 from xlutils.copy import copy
 
 from ctools import cjson
-from ctools.word_fill_entity import WordTable, WordCell, Style, Font, Alignment
+from ctools.office.word_fill_entity import WordTable, WordCell, Style, Font, Alignment
 
 EXCEL_WORD_ALIGNMENT = {"left": WD_TABLE_ALIGNMENT.LEFT,
                         "center": WD_TABLE_ALIGNMENT.CENTER,
@@ -469,6 +469,7 @@ def check_format(input_path: str):
     res = False
   return res
 
+
 def excel_optimize(input_path: str):
   """
   优化excel内容清除无法使用的隐患
@@ -492,9 +493,8 @@ def excel_optimize(input_path: str):
   except Exception as e:
     print("优化模板内容清除无法使用的隐患异常: %s" % e)
 
-
 # 示例用法：从第1行到第5行、从第1列到第3列的区域复制到Word文档中
-# excel_file = r'C:\Users\DELL\hylink/hylink-rpa/document\test-2024-04-01_09-05-26.xlsx'       # Excel文件名
+# excel_file = r'C:\Users\DELL\xxx/xxx-rpa/document\test-2024-04-01_09-05-26.xlsx'       # Excel文件名
 # excel_file_1 = r'E:\test\c.xlsx'       # Excel文件名
 # excel_file_2 = r'E:\test\b.xlsx'       # Excel文件名
 # word_file = r'E:\test\test.docx'     # 输出Word文件名
@@ -557,6 +557,3 @@ def excel_optimize(input_path: str):
 # print(check_format(input_path))
 
 # from docxtpl import DocxTemplate, RichText
-
-
-

ctools/patch.py

@@ -0,0 +1,88 @@
+import os
+
+from sqlalchemy.sql import text
+
+from ctools import path_info
+from ctools.database import database
+
+"""
+from ctools import patch
+def xx():
+  print('hello world')
+def xx1():
+  print('hello world1')
+def xx2():
+  print('hello world2')
+patch_funcs = {
+  'V1.0.2': xx,
+  'V1.0.3': xx1,
+  'V1.1.4': xx2
+}
+patch.sync_version("kwc", "V1.1.5", patch_funcs)
+"""
+
+class Patch:
+
+  def __init__(self, oldVersion, newVersion, patch_func: dict) -> None:
+    super().__init__()
+    if oldVersion:
+      self.oldV = version_to_int(oldVersion)
+    else:
+      self.oldV = 0
+    self.currentV = version_to_int(newVersion)
+    self.snapshot = '-snapshot' in newVersion or (oldVersion is not None and '-snapshot' in oldVersion)
+    self.patch_func = patch_func
+
+  def apply_patch(self):
+    patch_methods = [method for method in self.patch_func.keys() if method and (method.startswith('V') or method.startswith('v'))]
+    patch_methods.sort(key=lambda x: version_to_int(x))
+    max_method_name = patch_methods[-1]
+    exec_max_method = False
+    for method_name in patch_methods:
+      slVersion = version_to_int(method_name)
+      if self.currentV > slVersion >= self.oldV:
+        if max_method_name == method_name: exec_max_method = True
+        method = self.patch_func[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 = self.patch_func[max_method_name]
+      method()
+      print('snapshot patch {} update success'.format(max_method_name))
+
+def version_to_int(version):
+  return int(version.replace('V', '').replace('v', '').replace('.', '').replace('-snapshot', ''))
+
+def run_sqls(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 sync_version(app_name, new_version, patch_func: dict):
+  destFilePath = os.path.join(path_info.get_user_work_path(".ck/{}".format(app_name), mkdir=True), "version")
+  if not os.path.exists(destFilePath):
+    patch = Patch(oldVersion=None, newVersion=new_version, patch_func=patch_func)
+    patch.apply_patch()
+    with open(destFilePath, 'w') as nv:
+      nv.write(new_version)
+      print('初始化安装, 版本信息为: {}'.format(new_version))
+      nv.flush()
+  else:
+    with open(destFilePath, 'r') as oldVersion:
+      oldV = oldVersion.readline()
+      print('本地版本信息为: {}, 程序版本信息为: {}'.format(oldV, new_version))
+      oldVersion.close()
+    if oldV >= new_version and '-snapshot' not in oldV: return
+    print('开始升级本地程序..')
+    patch = Patch(oldVersion=oldV, newVersion=new_version, patch_func=patch_func)
+    patch.apply_patch()
+    with open(destFilePath, 'w') as newVersion:
+      newVersion.write(new_version)
+      print('程序升级成功, 更新版本信息为: {}'.format(new_version))
+      newVersion.flush()

ctools/{work_path.py → path_info.py}

@@ -1,6 +1,9 @@
 import inspect
 import os
 import sys
+import importlib
+from types import ModuleType
+from pathlib import Path
 
 
 def get_current_path(subPath: str = '') -> str:
@@ -33,13 +36,16 @@ def get_app_path(subPath: str = '') -> str:
   return os.path.join(base_path, subPath)
 
 
-def get_user_work_path(subPath: str = '') -> str:
+def get_user_work_path(subPath: str = '', mkdir: bool = False):
   """
   获取用户工作目录
   :param subPath: 拼接的子路径
+  :param mkdir: 是否创建目录
   :return: 用户工作目录
   """
-  return os.path.join(os.path.expanduser("~"), subPath)
+  path = os.path.join(os.path.expanduser("~"), subPath)
+  if mkdir and not os.path.exists(path): os.makedirs(path, exist_ok=True)
+  return path
 
 
 def get_user_temp_path(subPath: str = '') -> str:
@@ -64,3 +70,29 @@ def get_install_path(subPath: str = '') -> str:
   :return: 安装包安装的路径
   """
   return os.path.join(os.getcwd(), subPath)
+
+def get_package_path(package: str | ModuleType) -> Path:
+  """
+  获取包所在目录
+  :param package: 包名字符串或已导入模块
+  :return: 包目录的 Path 对象
+  """
+  if isinstance(package, str):
+    module = importlib.import_module(package)
+  elif isinstance(package, ModuleType):
+    module = package
+  else:
+    raise TypeError("package 必须是字符串或模块对象")
+
+  return Path(module.__file__).resolve().parent
+
+
+def get_resource_path(package: str | ModuleType, *subpaths: str) -> Path:
+  """
+  获取包内资源文件路径（自动拼接子路径）
+  :param package: 包名或模块
+  :param subpaths: 可变参数，表示路径中的子目录或文件名
+  :return: 资源的绝对路径
+  """
+  base = get_package_path(package)
+  return base.joinpath(*subpaths)

ctools/pkg/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/7/15 11:02'