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

ctools/douglas_rarefy.py

@@ -0,0 +1,136 @@
+#!/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/download_tools.py

@@ -0,0 +1,57 @@
+import os
+from urllib.parse import urlencode
+
+from bottle import static_file, HTTPResponse
+
+from ctools import sys_log, http_utils
+
+log = sys_log.flog
+
+"""
+文件下载服务
+"""
+
+
+def download(file_path: str, download_name:str=None):
+  """
+  文件下载
+  :param file_path: 静态文件路径
+  :param download_name: 下载文件名
+  :return:
+  """
+  if os.path.exists(file_path):
+    root_path = os.path.split(file_path)[0]
+    file_name = os.path.split(file_path)[1]
+    download_filename = urlencode({'filename': download_name or file_name}).split("=")[-1]  # 对文件名进行URL编码
+    response = static_file(file_name, root=root_path, download=True)
+    # 设置响应头，告诉浏览器这是一个文件下载
+    response.headers['Content-Type'] = 'application/octet-stream;charset=utf-8'
+    response.headers['Content-Disposition'] = f'attachment; filename={download_filename}'
+    log.debug(f"下载文件成功, file_path： {file_path}, file_name： {file_name}, download_name： {download_name}")
+  else:
+    response = None
+    log.info("下载文件失败, 此文件不存在, file_path： %s" % file_path)
+  return response
+
+
+def download_bytes(file_bytes: bytes, download_name: str):
+  """
+  文件下载
+  :param file_bytes: file_bytes
+  :param download_name: download_name
+  :return:
+  """
+  download_filename = urlencode({'filename': download_name}).split("=")[-1]  # 对文件名进行URL编码
+  # 设置响应头，告诉浏览器这是一个文件下载
+  headers = {"Accept-Ranges": "bytes", "Content-Length": len(file_bytes),
+             'Content-Type': 'application/octet-stream;charset=utf-8',
+             'Content-Disposition': f'attachment; filename={download_filename}'}
+  return HTTPResponse(file_bytes, **headers)
+
+
+def download_url(url: str, save_path: str):
+  content = http_utils.get(url)
+  if content:
+    with open(save_path, "wb") as f:
+      f.write(content)
+  return save_path

ctools/enums.py

@@ -0,0 +1,4 @@
+def value_of(e, v):
+  for member_name, member in e.__members__.items():
+    if member.value == v:
+      return member

ctools/ex.py

@@ -0,0 +1,31 @@
+import time
+import traceback
+from functools import wraps
+
+# annotation
+def exception_handler(fail_return, retry_num=0, delay=3, catch_e=Exception, print_exc=False):
+  def decorator(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+      try:
+        return func(*args, **kwargs)
+      except catch_e as e:
+        print(f"{func.__name__} runtime exception: {str(e)}")
+        if print_exc: traceback.print_exc()
+        nonlocal retry_num
+        renum = retry_num
+        if renum == 0:
+          return fail_return
+        else:
+          while renum > 0:
+            time.sleep(delay)
+            renum -= 1
+            try:
+              return func(*args, **kwargs)
+            except catch_e:
+              pass
+          return fail_return
+
+    return wrapper
+
+  return decorator

ctools/excelOpt.py

@@ -0,0 +1,36 @@
+from openpyxl import load_workbook
+from openpyxl.worksheet.datavalidation import DataValidation
+
+
+class excelUtil:
+  wb = None
+  sourcePath = None
+  savePath = None
+
+  def __init__(self, path, save_path):
+    # 创建一个 Workbook 对象
+    self.wb = load_workbook(path)
+    # 在 Workbook 中创建一个 Worksheet 对象
+    self.ws = self.wb.active
+    self.sourcePath = path
+    self.savePath = save_path
+
+  def makeDropData(self, col, drop_data):
+    # 定义下拉框的数据
+    dropdown_items = drop_data
+    # 将下拉框数据转换成字符串
+    dropdown_items_str = ','.join(dropdown_items)
+    # 在第一列中添加下拉框
+    dropdown_col = col
+    dropdown_start_row = 2
+    dropdown_end_row = 200
+    # 配置下拉框参数
+    dropdown = DataValidation(type="list", formula1=f'"{dropdown_items_str}"', allow_blank=True)
+    # 添加下拉框到指定的单元格区域
+    dropdown_range = f"{dropdown_col}{dropdown_start_row}:{dropdown_col}{dropdown_end_row}"
+    self.ws.add_data_validation(dropdown)
+    dropdown.add(dropdown_range)
+
+  def save(self):
+    # 保存工作簿
+    self.wb.save(self.savePath)

ctools/html_soup.py

@@ -0,0 +1,35 @@
+from bs4 import BeautifulSoup
+
+from ctools.ex import exception_handler
+
+
+@exception_handler(fail_return=['解析错误'], print_exc=True)
+def table2list(html, include_header=True, recursive_find=True,
+               table_tag='table', table_class=None, table_attrs: dict = {},
+               row_tag='tr', row_class=None, row_attrs: dict = {},
+               header_cell_tag='th', header_cell_class=None, header_cell_attrs: dict = {},
+               cell_tag='td', cell_class=None, cell_attrs: dict = {}):
+  soup = BeautifulSoup(markup=html, features='html.parser')
+  if table_class:
+    table = soup.find(table_tag, class_=table_class, **table_attrs)
+  else:
+    table = soup.find(table_tag, **table_attrs)
+  if row_class:
+    all_row = table.find_all(row_tag, class_=row_class, recursive=recursive_find, **row_attrs)
+  else:
+    all_row = table.find_all(row_tag, recursive=recursive_find, **row_attrs)
+  rows = []
+  if include_header:
+    if header_cell_class:
+      header = [i.text for i in all_row[0].find_all(header_cell_tag, class_=header_cell_class, recursive=recursive_find, **header_cell_attrs)]
+    else:
+      header = [i.text for i in all_row[0].find_all(header_cell_tag, recursive=recursive_find, **header_cell_attrs)]
+    rows.append(header)
+  for tr in all_row[1 if include_header else 0:]:
+    if cell_class:
+      td = tr.find_all(cell_tag, class_=cell_class, recursive=recursive_find, **cell_attrs)
+    else:
+      td = tr.find_all(cell_tag, recursive=recursive_find, **cell_attrs)
+    row = [i.text for i in td]
+    rows.append(row)
+  return rows

ctools/http_utils.py

@@ -0,0 +1,24 @@
+import requests
+
+
+def get(url, params=None, headers=None):
+  result = ""
+  try:
+    response = requests.get(url, params=params, headers=headers, timeout=60, verify=False)
+    response.raise_for_status()
+    if response.status_code == 200:
+      result = response.content
+  except Exception as e:
+    print("GET请求异常:", e)
+  if isinstance(result, bytes): return result.decode('utf-8')
+  return result
+
+
+def post(url, data=None, json=None, headers=None, files=None):
+  result = ""
+  response = requests.post(url, data=data, json=json, files=files, headers=headers, timeout=60, verify=False)
+  response.raise_for_status()
+  if response.status_code == 200:
+    result = response.content
+  if isinstance(result, bytes): return result.decode('utf-8')
+  return result

ctools/images_tools.py

@@ -0,0 +1,27 @@
+from io import BytesIO
+
+from PIL import Image
+
+
+def get_size(image_path):
+  return Image.open(image_path).size
+
+def change_color(image_path, area=None, rgb_color=None):
+  """
+  修改图片指定区域颜色
+  :param image_path: 图片路径
+  :param area: 修改区域： (x1, y1, x2, y2)
+  :param rgb_color: 入盘颜色 (255, 0, 0)
+  :return:
+  """
+  with Image.open(image_path) as img:
+    if area:
+      pixels = img.load()
+      for x in range(area[0], area[2]):
+        for y in range(area[1], area[3]):
+          pixels[x, y] = rgb_color
+    img_bytes = BytesIO()
+    img.save(img_bytes, format='JPEG')
+    img_binary = img_bytes.getvalue()
+  return img_binary
+

ctools/imgDialog.py

@@ -0,0 +1,44 @@
+import tkinter
+import tkinter as tk
+from io import BytesIO
+from tkinter import ttk
+
+import requests
+from PIL import Image, ImageTk
+
+def showImageTip(root, title, imagePath, tips):
+  # 创建一个Tk对象
+  if root:
+    window = root
+  else:
+    window = tk.Tk()
+  # 设置窗口大小和位置
+  win_width = 400
+  win_height = 480
+  screen_width = window.winfo_screenwidth()
+  screen_height = window.winfo_screenheight()
+  x = int((screen_width - win_width) / 2)
+  y = int((screen_height - win_height) / 2)
+  window.geometry("{}x{}+{}+{}".format(win_width, win_height, x, y))
+
+  # 设置窗口大小和标题
+  window.title(title)
+
+  # 创建一个Label控件用于显示图片
+  resp = requests.get(imagePath)
+  image = Image.open(BytesIO(resp.content))  # 替换你自己的图片路径
+  image = image.resize((400, 400))
+  photo = ImageTk.PhotoImage(image)
+  label1 = ttk.Label(window, image=photo)
+  label1.pack(side=tkinter.TOP)
+
+  # 创建一个Label控件用于显示提示文字
+  label2 = ttk.Label(window, text=tips, font=("Arial Bold", 16))
+  label2.config(anchor='center', justify='center')
+  label2.pack(side=tkinter.BOTTOM)
+  # 显示窗口
+  window.mainloop()
+
+
+if __name__ == '__main__':
+  showImageTip(root=None, title='在线授权', imagePath='https://blog.gomyck.com/img/pay-img/wechatPay2Me.jpg', tips='{}\n授权已失效,请联系微信:\n{}'.format(123, 123))

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)