gomyck-tools 1.5.3__py3-none-any.whl → 1.5.5__py3-none-any.whl

ctools/ml/ppi.py

@@ -0,0 +1,276 @@
+from io import BytesIO
+from queue import Queue
+
+import numpy as np
+import yaml
+from PIL import Image
+from paddle.inference import Config, create_predictor
+
+from ctools import path_info
+from ctools.ml.image_process import preprocess
+from ctools.ml.img_extractor import ClassRegionBase64ExtractorPIL
+
+
+class PaddlePredictorPool:
+  """Predictor 池，用于多线程安全推理"""
+  def __init__(self, config_path, pool_size: int = 4):
+    """
+    初始化预测器池
+    Note: 每个 Config 对象只能创建一个 predictor，所以我们需要保存 config_path
+    """
+    self.config_path = config_path
+    self.pool = Queue()
+    self._init_pool(pool_size)
+
+  def _load_config_yaml(self):
+    """加载 yaml 配置"""
+    with open(self.config_path, "r", encoding="utf-8") as f:
+      return yaml.safe_load(f)
+
+  def _create_config(self):
+    """为新的 predictor 创建一个新的 Config 对象"""
+    cfg = self._load_config_yaml()
+    model_dir = cfg.get("MODEL_DIR", "")
+    model_file = cfg.get("MODEL_FILE", "")
+    if not model_file:
+      model_dir = path_info.get_app_path('mod/model.pdmodel')
+    params_file = cfg.get("PARAMS_FILE", "")
+    if not params_file:
+      model_dir = path_info.get_app_path('mod/model.pdiparams')
+    use_gpu = cfg.get("USE_GPU", False)
+
+    if model_dir:
+      config = Config(model_dir)
+    else:
+      config = Config(model_file, params_file)
+
+    config.enable_memory_optim()
+
+    if use_gpu:
+      config.enable_use_gpu(1000, 0)
+    else:
+      config.set_cpu_math_library_num_threads(4)
+      config.enable_mkldnn()
+
+    return config
+
+  def _init_pool(self, pool_size: int):
+    """初始化池中的所有 predictor"""
+    for _ in range(pool_size):
+      config = self._create_config()
+      predictor = create_predictor(config)
+      self.pool.put(predictor)
+
+  def acquire(self, timeout=None):
+    """从池中获取一个 predictor"""
+    return self.pool.get(timeout=timeout)
+
+  def release(self, predictor):
+    """将 predictor 放回池中"""
+    self.pool.put(predictor)
+
+
+class PaddleInferenceEngine:
+  def __init__(self, config_path, pool_size=4):
+    self.config_path = config_path
+    self.cfg = self._load_config(config_path)
+    self.predictor_pool = PaddlePredictorPool(config_path, pool_size=pool_size)
+
+  def _load_config(self, config_path):
+    with open(config_path, "r", encoding="utf-8") as f:
+      return yaml.safe_load(f)
+
+  def predict(self, inputs, timeout=None):
+    """线程安全预测"""
+    predictor = self.predictor_pool.acquire(timeout=timeout)
+    try:
+      input_names = predictor.get_input_names()
+      for name in input_names:
+        if name not in inputs:
+          raise ValueError(f"缺少模型输入: {name}")
+        tensor = predictor.get_input_handle(name)
+        data = inputs[name]
+        tensor.reshape(data.shape)
+        tensor.copy_from_cpu(data)
+      predictor.run()
+      outputs = []
+      for name in predictor.get_output_names():
+        out = predictor.get_output_handle(name)
+        outputs.append(out.copy_to_cpu())
+      return outputs
+    finally:
+      self.predictor_pool.release(predictor)
+
+  def predict_image(self, img, im_size=320):
+    if isinstance(img, bytes):
+      img = Image.open(BytesIO(img)).convert("RGB")
+    elif isinstance(img, Image.Image):
+      img = img.convert("RGB")
+    elif isinstance(img, np.ndarray):
+      pass
+    else:
+      raise ValueError("Unsupported image type for predict_image")
+    orig_img_np = np.array(img) if not isinstance(img, np.ndarray) else img
+    data = preprocess(orig_img_np, im_size)
+    scale_factor = np.array([im_size * 1. / orig_img_np.shape[0], im_size * 1. / orig_img_np.shape[1]]).reshape((1, 2)).astype(np.float32)
+    im_shape = np.array([im_size, im_size]).reshape((1, 2)).astype(np.float32)
+    outputs = self.predict({"image": data, "im_shape": im_shape, "scale_factor": scale_factor})
+    return outputs, scale_factor, im_size
+
+  def predict_image_and_extract(self, img, im_size=320, class_names=None, target_classes=None, threshold=0.3):
+    """预测并提取检测区域"""
+    raw_outputs, scale_factor, im_size_ret = self.predict_image(img, im_size=im_size)
+
+    # 转换为 PIL Image
+    if isinstance(img, bytes):
+      pil_img = Image.open(BytesIO(img)).convert("RGB")
+    elif isinstance(img, Image.Image):
+      pil_img = img.convert("RGB")
+    elif isinstance(img, np.ndarray):
+      pil_img = Image.fromarray(img.astype('uint8')).convert("RGB")
+    else:
+      raise ValueError("Unsupported image type")
+
+    # 提取检测区域
+    extractor = ClassRegionBase64ExtractorPIL(class_names or [], target_classes=target_classes, threshold=threshold)
+    detection_results = raw_outputs[0]
+    return extractor.extract(pil_img, detection_results, scale_factor=scale_factor, im_size=im_size_ret)
+
+  @staticmethod
+  def _nms_detections(detections, iou_threshold=0.5):
+    if len(detections) == 0:
+      return detections
+    dets = np.array(detections, dtype=np.float32)
+    scores = dets[:, 1]
+    sorted_idx = np.argsort(-scores)
+    keep = []
+    while len(sorted_idx) > 0:
+      current_idx = sorted_idx[0]
+      keep.append(current_idx)
+      if len(sorted_idx) == 1:
+        break
+      current_box = dets[current_idx, 2:6]
+      other_boxes = dets[sorted_idx[1:], 2:6]
+      x1_inter = np.maximum(current_box[0], other_boxes[:, 0])
+      y1_inter = np.maximum(current_box[1], other_boxes[:, 1])
+      x2_inter = np.minimum(current_box[2], other_boxes[:, 2])
+      y2_inter = np.minimum(current_box[3], other_boxes[:, 3])
+      inter_area = np.maximum(0, x2_inter - x1_inter) * np.maximum(0, y2_inter - y1_inter)
+      area_current = (current_box[2] - current_box[0]) * (current_box[3] - current_box[1])
+      area_others = (other_boxes[:, 2] - other_boxes[:, 0]) * (other_boxes[:, 3] - other_boxes[:, 1])
+      union_area = area_current + area_others - inter_area
+      iou = inter_area / (union_area + 1e-6)
+      valid_idx = np.where(iou < iou_threshold)[0] + 1
+      sorted_idx = sorted_idx[valid_idx]
+    return dets[keep].tolist()
+
+  def predict_image_tiled(self, img, im_size=320, tile_overlap=0.2, class_names=None, target_classes=None, threshold=0.3, nms_iou=0.5):
+    """
+    Tiled prediction for large images (2K, 4K, etc).
+    Splits image into overlapping tiles, predicts each tile, merges results.
+
+    Args:
+      img: PIL Image, numpy array, or bytes
+      im_size: model training resolution (e.g., 320)
+      tile_overlap: overlap ratio between tiles (0.0-1.0), default 0.2
+      class_names: list of class names
+      target_classes: list of target classes to extract
+      threshold: confidence threshold
+      nms_iou: IoU threshold for NMS merging
+
+    Returns:
+      extracted_outputs: list of dicts with extracted regions (with coordinates mapped to original image)
+      all_detections: list of raw detections [cat_id, score, xmin, ymin, xmax, ymax] (original image coords)
+    """
+    # Convert input to numpy array
+    if isinstance(img, bytes):
+      pil_img = Image.open(BytesIO(img)).convert("RGB")
+      img_np = np.array(pil_img)
+    elif isinstance(img, Image.Image):
+      img_np = np.array(img.convert("RGB"))
+    elif isinstance(img, np.ndarray):
+      img_np = img
+    else:
+      raise ValueError("Unsupported image type for predict_image_tiled")
+    orig_h, orig_w = img_np.shape[:2]
+    # Calculate tile parameters
+    stride = int(im_size * (1 - tile_overlap))
+    stride = max(1, stride)
+    # Generate tile coordinates
+    tiles = []
+    y_start = 0
+    while y_start < orig_h:
+      y_end = min(y_start + im_size, orig_h)
+      # If last tile doesn't cover the bottom, adjust
+      if y_end == orig_h and y_start > 0:
+        y_start = max(0, orig_h - im_size)
+        y_end = orig_h
+      x_start = 0
+      while x_start < orig_w:
+        x_end = min(x_start + im_size, orig_w)
+        # If last tile doesn't cover the right, adjust
+        if x_end == orig_w and x_start > 0:
+          x_start = max(0, orig_w - im_size)
+          x_end = orig_w
+        tiles.append((x_start, y_start, x_end, y_end))
+        x_start += stride
+        if x_end == orig_w:
+          break
+      y_start += stride
+      if y_end == orig_h:
+        break
+    # Predict each tile and collect detections
+    all_detections = []
+    for x_start, y_start, x_end, y_end in tiles:
+      tile_img = img_np[y_start:y_end, x_start:x_end]
+      # Pad tile if smaller than im_size
+      if tile_img.shape[0] < im_size or tile_img.shape[1] < im_size:
+        pad_h = im_size - tile_img.shape[0]
+        pad_w = im_size - tile_img.shape[1]
+        tile_img = np.pad(tile_img, ((0, pad_h), (0, pad_w), (0, 0)), mode='constant', constant_values=0)
+      # Run inference on tile
+      try:
+        tile_outputs, _, _ = self.predict_image(tile_img, im_size=im_size)
+        tile_detections = tile_outputs[0]
+        # Map coordinates back to original image
+        for det in tile_detections:
+          cat_id, score = det[0], det[1]
+          xmin, ymin, xmax, ymax = det[2], det[3], det[4], det[5]
+          # Scale from model resolution to tile resolution
+          tile_h, tile_w = y_end - y_start, x_end - x_start
+          xmin_tile = xmin * tile_w / im_size
+          ymin_tile = ymin * tile_h / im_size
+          xmax_tile = xmax * tile_w / im_size
+          ymax_tile = ymax * tile_h / im_size
+          # Translate to original image coordinates
+          xmin_orig = xmin_tile + x_start
+          ymin_orig = ymin_tile + y_start
+          xmax_orig = xmax_tile + x_start
+          ymax_orig = ymax_tile + y_start
+          # Clip to image bounds
+          xmin_orig = max(0, min(xmin_orig, orig_w))
+          ymin_orig = max(0, min(ymin_orig, orig_h))
+          xmax_orig = max(0, min(xmax_orig, orig_w))
+          ymax_orig = max(0, min(ymax_orig, orig_h))
+          all_detections.append([cat_id, score, xmin_orig, ymin_orig, xmax_orig, ymax_orig])
+      except Exception as e:
+        print(f"Error processing tile {(x_start, y_start, x_end, y_end)}: {e}")
+        continue
+    # Apply NMS to merge duplicate detections
+    merged_detections = self._nms_detections(all_detections, iou_threshold=nms_iou)
+
+    # Extract regions using the merged detections
+    if isinstance(img, bytes):
+      pil_img = Image.open(BytesIO(img)).convert("RGB")
+    elif isinstance(img, Image.Image):
+      pil_img = img.convert("RGB")
+    elif isinstance(img, np.ndarray):
+      pil_img = Image.fromarray(img_np.astype('uint8')).convert("RGB")
+    else:
+      raise ValueError("Unsupported image type")
+
+    # Create a dummy scale_factor (1:1 since we're already in original coordinates)
+    scale_factor = np.array([[1.0, 1.0]], dtype=np.float32)
+    extractor = ClassRegionBase64ExtractorPIL(class_names or [], target_classes=target_classes, threshold=threshold)
+    extracted = extractor.extract(pil_img, merged_detections, scale_factor=scale_factor, im_size=orig_h)
+    return extracted, merged_detections

ctools/stream/ckafka.py

@@ -15,7 +15,7 @@ from ctools.cjson import dumps
 import time
 from datetime import datetime
 
-from ctools import thread_pool, string_tools
+from ctools import thread_pool, cid
 from ctools.ckafka import CKafka
 
 c = CKafka(kafka_url='192.168.3.160:9094', secure=True)
@@ -27,7 +27,7 @@ def send_msg():
   while True:
     command = input('发送消息: Y/n \n')
     if command.strip() not in ['N', 'n']:
-      producer.send_msg('jqxx', '{{"jqid": "{}", "xxxx": "{}"}}'.format(string_tools.get_snowflake_id(), datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')))
+      producer.send_msg('jqxx', '{{"jqid": "{}", "xxxx": "{}"}}'.format(cid.get_snowflake_id(), datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')))
     else:
       break
 

ctools/sys_log.py

@@ -1,96 +1,170 @@
-import logging
-import os
 import sys
+import os
 import time
-
-from ctools import call, path_info
-
-clog: logging.Logger = None
-flog: logging.Logger = None
-
-neglect_keywords = [
-  "OPTIONS",
-]
-
-
-# 文件日志
-@call.once
-def _file_log(sys_log_path: str = './', log_level: int = logging.INFO, mixin: bool = False) -> logging:
-  try:
-    os.mkdir(sys_log_path)
-  except Exception:
-    pass
-  log_file = sys_log_path + os.path.sep + "log-" + time.strftime("%Y-%m-%d-%H", time.localtime(time.time())) + ".log"
-  if mixin:
-    handlers = [logging.FileHandler(filename=log_file, encoding='utf-8'), logging.StreamHandler()]
-  else:
-    handlers = [logging.FileHandler(filename=log_file, encoding='utf-8')]
-  logging.basicConfig(level=log_level,
-                      format='%(asctime)s | %(levelname)-5s | T%(thread)d | %(module)s.%(funcName)s:%(lineno)d: %(message)s',
-                      datefmt='%Y%m%d%H%M%S',
-                      handlers=handlers)
-  logger = logging.getLogger('ck-flog')
-  return logger
-
-
-# 控制台日志
-@call.once
-def _console_log(log_level: int = logging.INFO) -> logging:
-  handler = logging.StreamHandler()
-  logging.basicConfig(level=log_level,
-                      format='%(asctime)s | %(levelname)-5s | T%(thread)d | %(name)s | %(module)s.%(funcName)s:%(lineno)d: %(message)s',
-                      datefmt='%Y%m%d%H%M%S',
-                      handlers=[handler])
-  logger = logging.getLogger('ck-clog')
-  return logger
-
-
-import io
 import logging
+from typing import Protocol
 
+from ctools import call
 
-class StreamToLogger(io.StringIO):
-  def __init__(self, logger: logging.Logger, level: int = logging.INFO):
-    super().__init__()
-    self.logger = logger
-    self.level = level
-    self._buffer = ''
 
-  def write(self, message: str):
-    if not message:
+# =========================
+# 日志接口（IDE 提示）
+# =========================
+class LoggerProtocol(Protocol):
+  def debug(self, msg: str, *args, **kwargs) -> None: ...
+  def info(self, msg: str, *args, **kwargs) -> None: ...
+  def warning(self, msg: str, *args, **kwargs) -> None: ...
+  def error(self, msg: str, *args, **kwargs) -> None: ...
+  def critical(self, msg: str, *args, **kwargs) -> None: ...
+  def exception(self, msg: str, *args, **kwargs) -> None: ...
+
+
+class _LazyLogger:
+  def __getattr__(self, item):
+    raise RuntimeError("Logger not initialized, call init_log() first")
+
+
+flog: LoggerProtocol = _LazyLogger()
+clog: LoggerProtocol = _LazyLogger()
+
+
+# =========================
+# TeeStream
+# =========================
+class TeeStream:
+  def __init__(self, *streams):
+    self.streams = streams
+
+  def write(self, data):
+    if not data:
       return
-    self._buffer += message
-    if '\n' in self._buffer:
-      lines = self._buffer.splitlines(keepends=False)
-      for line in lines:
-        if line.strip():
-          try:
-            self.logger.log(self.level, line.strip(), stacklevel=3)
-          except Exception:
-            self.logger.log(self.level, line.strip())
-      self._buffer = ''
+    for s in self.streams:
+      try:
+        s.write(data)
+      except Exception:
+        pass
 
   def flush(self):
-    if self._buffer.strip():
+    for s in self.streams:
       try:
-        self.logger.log(self.level, self._buffer.strip(), stacklevel=3)
+        s.flush()
       except Exception:
-        self.logger.log(self.level, self._buffer.strip())
-    self._buffer = ''
+        pass
+
+  def isatty(self):
+    return any(getattr(s, "isatty", lambda: False)() for s in self.streams)
 
   def fileno(self):
-    return sys.__stdout__.fileno()
+    for s in self.streams:
+      try:
+        return s.fileno()
+      except Exception:
+        pass
+    raise OSError
 
 
+# =========================
+# print → 文件
+# =========================
+class PrintToFile:
+  def __init__(self, file_handler: logging.Handler, level=logging.INFO):
+    self.handler = file_handler
+    self.level = level
+    self._buffer = ""
+
+  def write(self, msg):
+    if not msg:
+      return
+    self._buffer += msg
+    while "\n" in self._buffer:
+      line, self._buffer = self._buffer.split("\n", 1)
+      line = line.rstrip()
+      if line:
+        record = logging.LogRecord(
+          name="print",
+          level=self.level,
+          pathname="",
+          lineno=0,
+          msg=line,
+          args=(),
+          exc_info=None,
+        )
+        self.handler.emit(record)
+
+  def flush(self):
+    if self._buffer.strip():
+      record = logging.LogRecord(
+        name="print",
+        level=self.level,
+        pathname="",
+        lineno=0,
+        msg=self._buffer.strip(),
+        args=(),
+        exc_info=None,
+      )
+      self.handler.emit(record)
+      self._buffer = ""
+
+  def isatty(self):
+    return False
+
+
+# =========================
+# 初始化日志
+# =========================
 @call.init
-def _init_log() -> None:
+def init_log():
   global flog, clog
-  flog = _file_log(path_info.get_user_work_path(".ck/ck-py-log", mkdir=True), mixin=True, log_level=logging.DEBUG)
-  clog = _console_log()
-  sys.stdout = StreamToLogger(flog, level=logging.INFO)
-  sys.stderr = StreamToLogger(flog, level=logging.ERROR)
 
+  # 绝对路径
+  home_dir = os.path.expanduser("~")
+  log_dir = os.path.join(home_dir, ".ck", "ck-py-log")
+  os.makedirs(log_dir, exist_ok=True)
+
+  log_file = os.path.join(
+    log_dir, f"log-{time.strftime('%Y-%m-%d-%H')}.log"
+  )
+
+  formatter = logging.Formatter(
+    "%(asctime)s | %(levelname)-8s | %(name)s:%(lineno)d - %(message)s"
+  )
+
+  # ===== 文件 handler =====
+  file_handler = logging.FileHandler(log_file, encoding="utf-8")
+  file_handler.setLevel(logging.DEBUG)
+  file_handler.setFormatter(formatter)
+
+  # ===== 控制台 handler =====
+  console_handler = logging.StreamHandler(sys.stderr)
+  console_handler.setLevel(logging.INFO)
+  console_handler.setFormatter(formatter)
+
+  # ===== logger =====
+  logger = logging.getLogger("app")
+  logger.setLevel(logging.DEBUG)
+  logger.handlers.clear()
+  logger.addHandler(file_handler)
+  logger.addHandler(console_handler)
+  logger.propagate = False
+
+  flog = logger
+  clog = logger
+
+  # ===== stdout / stderr tee =====
+  original_stdout = sys.stdout
+  original_stderr = sys.stderr
+
+  sys.stdout = TeeStream(
+    original_stdout,
+    PrintToFile(file_handler, level=logging.INFO)
+  )
+
+  sys.stderr = TeeStream(
+    original_stderr,
+    PrintToFile(file_handler, level=logging.ERROR)
+  )
+
+  # 确认文件已经创建
+  if not os.path.isfile(log_file):
+    raise RuntimeError(f"日志文件未创建: {log_file}")
 
-def setLevel(log_level=logging.INFO):
-  flog.setLevel(log_level)
-  clog.setLevel(log_level)

ctools/util/jb_cut.py

@@ -3,7 +3,6 @@
 __author__ = 'haoyang'
 __date__ = '2025/7/15 13:08'
 
-import sys
 from collections import Counter
 
 import jieba

ctools/web/bottle_web_base.py

@@ -207,6 +207,7 @@ def params_resolve(func):
         dict_wrapper = DictWrapper({'body': params})
         dict_wrapper.update(query_params.dict)
         return func(params=auto_exchange(func, dict_wrapper), *args, **kwargs)
+      return None
     else:
       return func(*args, **kwargs)
 

ctools/web/bottle_webserver.py

@@ -19,7 +19,9 @@ from ctools.util.config_util import load_config
 from ctools.web import bottle_web_base, bottle_webserver
 from key_word_cloud.db_core.db_init import init_partitions
 from patch_manager import patch_funcs
+from ctools.web.ctoken import CToken
 
+CToken.token_audience = 'server-name'
 database.init_db('postgresql://postgres:123123@192.168.xx.xx:5432/xxx', default_schema='xxx', auto_gen_table=False, echo=False)
 
 config = load_config('application.ini')
@@ -31,7 +33,7 @@ app = bottle_web_base.init_app("/api", True)
 
 @bottle_web_base.before_intercept(0)
 def token_check():
-    return bottle_web_base.common_auth_verify(config.base.secret_key)
+    return bottle_web_base.common_auth_verify()
 
 if __name__ == '__main__':
   main_server = bottle_webserver.init_bottle(app)
@@ -41,7 +43,6 @@ if __name__ == '__main__':
 
 _default_port = 8888
 
-
 class CBottle:
 
   def __init__(self, bottle: Bottle, port=_default_port, quiet=False):
@@ -56,6 +57,7 @@ class CBottle:
     self.static_root = './static'
     self.download_root = './download'
     self.template_root = './templates'
+    self.server_path = '/api/'
 
     @self.bottle.route(['/', '/index'])
     def index():
@@ -120,33 +122,35 @@ class CBottle:
 
   def run(self):
     http_server = WSGIRefServer(port=self.port)
-    print('Click the link below to open the service homepage %s' % '\n \t\t http://localhost:%s \n \t\t http://%s:%s' % (self.port, sys_info.get_local_ipv4(), self.port), file=sys.stderr)
+    print('Click the link below to open the service homepage %s' % '\n \t\t http://localhost:%s \n \t\t http://%s:%s \n' % (self.port, sys_info.get_local_ipv4(), self.port), file=sys.stderr)
     cache_white_list(self.bottle)
     self.bottle.run(server=http_server, quiet=self.quiet)
 
   def enable_spa_mode(self):
     @self.bottle.error(404)
     def error_404_handler(error):
-      if request.path.startswith('/api/'):
+      if request.path.startswith(self.server_path):
         response.status = 404
         return R.error(resp=R.Code.cus_code(404, "资源未找到: {}".format(error.body)))
       return static_file(filename=self.index_filename, root=self.index_root)
 
     @self.bottle.error(401)
     def unauthorized(error):
-      if request.path.startswith('/api/'):
+      if request.path.startswith(self.server_path):
         response.status = 401
         return R.error(resp=R.Code.cus_code(401, "系统未授权! {}".format(error.body)))
       response.status=301
       response.set_header('Location', urljoin(request.url, '/'))
       return response
 
-  def set_index(self, filename='index.html', root='./', is_tpl=False, redirect_url=None, spa=False, **kwargs):
+  def set_index(self, filename='index.html', root='./', is_tpl=False, redirect_url=None, spa=False, server_path="/api/", **kwargs):
     self.index_root = root
     self.index_filename = filename
     self.is_tpl = is_tpl
     self.redirect_url = redirect_url
-    if spa: self.enable_spa_mode()
+    if spa:
+      self.server_path = server_path
+      self.enable_spa_mode()
     self.tmp_args = kwargs
 
   def set_static(self, root='./static'):

ctools/web/bottle_websocket.py

@@ -19,7 +19,7 @@ def get_ws_modules():
 """
 
 """
-ws_app = bottle_web_base.init_app('/websocket_demo')
+ws_app = bottle_web_base.init_app('/websocket_demo', main_app=True)
 
 @ws_app.route('/script_debug', apply=[websocket])
 @bottle_web_base.rule('DOC:DOWNLOAD')

ctools/web/ctoken.py

@@ -13,7 +13,7 @@ from ctools.dict_wrapper import DictWrapper
 
 
 class CToken:
-  token_audience = ["gomyck"]
+  token_audience = ["gomyck"]     # token 受众: 颁发至哪个服务, 不同服务要修改这个值, 避免服务之间 token 泄漏
   token_secret_key = 'gomyck123'
   token_header = 'Authorization'