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

ctools/database.py

@@ -0,0 +1,185 @@
+import contextlib
+import datetime
+import math
+
+from sqlalchemy import create_engine, Integer, Column, event
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.sql import text
+
+from ctools import call, string_tools
+from ctools.thread_pool import thread_local
+
+"""
+class XXXX(BaseMixin):
+  __tablename__ = 't_xxx_info'
+  __table_args__ = {'comment': 'xxx信息表'}
+  server_content: Column = Column(String(50), nullable=True, default='', comment='123123')
+  server_ip: Column = Column(String(30), index=True)
+  user_id: Column = Column(BigInteger)
+
+database.init_db('postgresql://postgres:123456@192.168.3.107:32566/abc', default_schema='public', db_key='source', pool_size=100)
+with database.get_session('source') as s:
+  s.execute(text('insert into xxx (name) values (:name)'), {'name': string_tools.get_random_str(5)})
+  s.commit()
+"""
+
+Base = None
+inited_db = {}
+engines = {}
+sessionMakers = {}
+
+def getEngine(db_key: str='default'):
+  return engines[db_key]
+
+@call.init
+def _init():
+  global Base
+  Base = declarative_base()
+
+"""
+The string form of the URL is
+dialect[+driver]://user:password@host/dbname[?key=value..]
+where ``dialect`` is a database name such as ``mysql``, ``oracle``, ``postgresql``, etc.
+and ``driver`` the name of a DBAPI such as ``psycopg2``, ``pyodbc``, ``cx_oracle``, etc.  Alternatively
+"""
+
+# 密码里的@  要替换成 %40
+
+# sqlite connect_args={"check_same_thread": False}  db_url=sqlite:///{}.format(db_url)
+# sqlite 数据库, 初始化之后, 优化一下配置
+# $ sqlite3 app.db
+# > PRAGMA journal_mode=WAL; 设置事务的模式, wal 允许读写并发, 但是会额外创建俩文件
+# > PRAGMA synchronous=NORMAL; 设置写盘策略, 默认是 FULL, 日志,数据都落, 设置成 NORMAL, 日志写完就算事务完成
+
+def init_db(db_url: str, db_key: str='default', connect_args: dict={}, default_schema: str=None, pool_size: int=5, max_overflow: int=25, echo: bool=False):
+  if db_url.startswith('mysql'):
+    import pymysql
+    pymysql.install_as_MySQLdb()
+  if inited_db.get(db_key): raise Exception('db {} already init!!!'.format(db_key))
+  global engines, sessionMakers
+  engine, sessionMaker = _create_connection(db_url=db_url, connect_args=connect_args, pool_size=pool_size, max_overflow=max_overflow, echo=echo)
+  engines[db_key] = engine
+  sessionMakers[db_key] = sessionMaker
+  inited_db[db_key] = True
+  if default_schema: event.listen(engine, 'connect', lambda dbapi_connection, connection_record: _set_search_path(dbapi_connection, default_schema))
+  Base.metadata.create_all(engine)
+
+def _set_search_path(dbapi_connection, default_schema):
+  with dbapi_connection.cursor() as cursor:
+    cursor.execute(f'SET search_path TO {default_schema}')
+
+def _create_connection(db_url: str, pool_size: int=5, max_overflow: int=25, connect_args={}, echo: bool=False):
+  engine = create_engine('{}'.format(db_url),
+                               echo=echo,
+                               future=True,
+                               pool_size=pool_size,
+                               max_overflow=max_overflow,
+                               pool_pre_ping=True,
+                               pool_recycle=3600,
+                               connect_args=connect_args)
+  sm = sessionmaker(bind=engine)
+  return engine, sm
+
+def generate_custom_id():
+  return str(string_tools.get_snowflake_id())
+
+class BaseMixin(Base):
+  __abstract__ = True
+  obj_id = Column(Integer, primary_key=True, default=generate_custom_id)
+
+  # ext1 = Column(String)
+  # ext2 = Column(String)
+  # ext3 = Column(String)
+  # create_time = Column(DateTime, nullable=False, default=datetime.datetime.now)
+  # update_time = Column(DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now, index=True)
+
+  def to_dict(self):
+    return self.__getstate__()
+
+  def from_dict(self, v):
+    self.__dict__.update(v)
+
+  def __getstate__(self):
+    ret_state = {}
+    state = self.__dict__.copy()
+    for key in state.keys():
+      if not key.startswith("_"):
+        if type(state[key]) == datetime.datetime:
+          ret_state[key] = state[key].strftime("%Y-%m-%d %H:%M:%S")
+        else:
+          ret_state[key] = state[key]
+    return ret_state
+
+@contextlib.contextmanager
+def get_session(db_key: str='default') -> Session:
+  thread_local.db_key = db_key
+  if sm:=sessionMakers.get(db_key):
+    s = sm()
+  else:
+    raise ValueError("Invalid db_key: {}".format(db_key))
+  try:
+    yield s
+  except Exception as e:
+    s.rollback()
+    raise e
+  finally:
+    s.close()
+
+class PageInfoBuilder:
+
+  def __init__(self, pageInfo, total_count, records):
+    self.page_size = pageInfo.page_size
+    self.page_index = pageInfo.page_index
+    self.total_count = total_count
+    self.total_page = math.ceil(total_count / int(pageInfo.page_size))
+    self.records = records
+
+def query_by_page(query, pageInfo):
+  records = query.offset((pageInfo.page_index - 1) * pageInfo.page_size).limit(pageInfo.page_size).all()
+  rs = []
+  for r in records:
+    rs.append(r)
+  return PageInfoBuilder(pageInfo, query.count(), rs)
+
+def query4_crd_sql(session, sql: str, params: dict) -> []:
+  records = session.execute(text(sql), params).fetchall()
+  rs = []
+  for record in records:
+    data = {}
+    for index, key in enumerate(record._mapping):
+      data[key] = record[index]
+    rs.append(data)
+  return rs
+
+sqlite_and_pg_page_sql = """
+ limit :limit offset :offset
+"""
+mysql_page_sql = """
+ limit :offset, :limit
+"""
+
+def query_by_page4_crd_sql(session, sql: str, params: dict, pageInfo) -> []:
+  db_name = engines[thread_local.db_key].name
+  if db_name == 'postgresql' or db_name == 'sqlite':
+    page_sql = sqlite_and_pg_page_sql
+  elif db_name == 'mysql':
+    page_sql = mysql_page_sql
+  else:
+    raise Exception('not support db: {}'.format(db_name))
+  wrapper_sql = """
+    select * from ({}) as t {}
+  """.format(sql, page_sql)
+  count_sql = """
+    select count(1) from ({}) as t
+  """.format(sql)
+  params["limit"] = pageInfo.page_size
+  params["offset"] = (pageInfo.page_index - 1) * pageInfo.page_size
+  records = session.execute(text(wrapper_sql), params).fetchall()
+  rs = []
+  for record in records:
+    data = {}
+    for index, key in enumerate(record._mapping):
+      data[key] = record[index]
+    rs.append(data)
+  return PageInfoBuilder(pageInfo, session.execute(text(count_sql), params).first()[0], rs)

ctools/date_utils.py

@@ -0,0 +1,43 @@
+import time
+from datetime import datetime, timedelta
+
+def get_date():
+  return time.strftime('%Y-%m-%d', time.localtime(time.time()))
+
+def get_time():
+  return time.strftime('%H-%M-%S', time.localtime(time.time()))
+
+def get_date_time(fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strftime(fmt, time.localtime(time.time()))
+
+def str_to_datetime(val: str, fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strptime(val, fmt)
+
+def str_to_timestamp(val: str, fmt="%Y-%m-%d %H:%M:%S"):
+  return time.mktime(time.strptime(val, fmt))
+
+def timestamp_to_str(timestamp: int=time.time(), fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strftime(fmt, time.localtime(timestamp))
+
+def get_today_start_end(now: datetime.now()):
+  start = datetime(now.year, now.month, now.day, 0, 0, 0)
+  end = datetime(now.year, now.month, now.day, 23, 59, 59)
+  return start.strftime("%Y-%m-%d %H:%M:%S"), end.strftime("%Y-%m-%d %H:%M:%S")
+
+def get_week_start_end(now: datetime.now()):
+  start = now - timedelta(days=now.weekday())  # 本周一
+  end = start + timedelta(days=6)  # 本周日
+  return start.strftime("%Y-%m-%d 00:00:00"), end.strftime("%Y-%m-%d 23:59:59")
+
+def time_diff_in_seconds(sub_head: str=get_date_time(), sub_end: str=get_date_time()):
+  start_ts = str_to_timestamp(sub_head)
+  end_ts = str_to_timestamp(sub_end)
+  return int(start_ts - end_ts)
+
+def opt_time(base_time=None, days=0, hours=0, minutes=0, seconds=0, weeks=0, fmt="%Y-%m-%d %H:%M:%S"):
+  if base_time is None:
+    base_time = datetime.now()
+  elif isinstance(base_time, str):
+    base_time = datetime.strptime(base_time, fmt)
+  new_time = base_time + timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds, weeks=weeks)
+  return new_time.strftime(fmt)

ctools/dict_wrapper.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/10/25 09:42'
+
+class DictWrapper(dict):
+
+  def __getattr__(self, key):
+    res = self.get(key)
+    if res is None:
+      raise AttributeError(f" ==>> {key} <<== Not Found In This Entity!!!")
+    if isinstance(res, dict):
+      return DictWrapper(res)
+    return res
+
+  def __setattr__(self, key, value):
+    self[key] = value
+
+  def __delattr__(self, key):
+    del self[key]

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))