gomyck-tools 1.5.4__py3-none-any.whl → 1.5.6__py3-none-any.whl

ctools/authcode_validator.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+授权码验证工具类
+仅用于验证授权码的有效性
+"""
+__author__ = 'haoyang'
+__date__ = '2026/1/26'
+
+from typing import Optional
+from datetime import datetime
+import json
+import ipaddress
+
+from ctools.cipher import sm_util
+
+
+class AuthCodeValidator:
+    """授权码验证器"""
+
+    def __init__(self, public_key: str = None):
+        """
+        初始化验证器
+
+        Args:
+            public_key: SM2公钥（用于签名验证）
+        """
+        if not public_key:
+            raise Exception("未提供公钥，无法初始化验证器。请传入 public_key 参数。")
+        self.public_key = public_key
+
+    def validate(self, authcode_json: str) -> bool:
+        """
+        快速验证授权码是否有效
+
+        Args:
+            authcode_json: 授权码JSON字符串
+
+        Returns:
+            bool: 授权码是否有效
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+        except:
+            return False
+
+        # 验证必需字段
+        if 'version' not in authcode_obj or 'body' not in authcode_obj or 'signature' not in authcode_obj:
+            return False
+
+        body = authcode_obj.get('body')
+        if not isinstance(body, dict):
+            return False
+
+        return self._verify_signature(authcode_json)
+
+    def _verify_signature(self, authcode_json: str) -> bool:
+        """
+        验证授权码签名
+
+        Args:
+            authcode_json: 授权码JSON字符串
+
+        Returns:
+            bool: 签名是否有效
+        """
+        if not self.public_key:
+            raise Exception("未初始化公钥，无法验证签名。请传入 public_key 参数。")
+
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+            signature = authcode_obj.get('signature', '')
+            version = authcode_obj.get('version', 'v1_1')
+
+            # 初始化SM2
+            sm_util.init(self.public_key, self.public_key)
+
+            # 构建签名字符串
+            final_val = self._build_sign_string(body, version)
+
+            # 验证签名
+            return sm_util.verify_with_sm2(signature, final_val)
+        except Exception as e:
+            try:
+                # 重试：重新初始化SM2并验证
+                authcode_obj = json.loads(authcode_json)
+                body = authcode_obj.get('body', {})
+                signature = authcode_obj.get('signature', '')
+                version = authcode_obj.get('version', 'v1_1')
+
+                sm_util.init(self.public_key, self.public_key)
+                final_val = self._build_sign_string(body, version)
+                return sm_util.verify_with_sm2(signature, final_val)
+            except:
+                return False
+
+    def _build_sign_string(self, body: dict, version: str) -> str:
+        """
+        构建签名字符串，与app.py中的签名逻辑一致
+
+        Args:
+            body: 授权码内容
+            version: 版本号
+
+        Returns:
+            str: 签名字符串
+        """
+        ordered_dict = sorted(body.items())
+        final_val = ""
+
+        for k, v in ordered_dict:
+            if isinstance(v, list):
+                value_str = ",".join(v)
+            else:
+                value_str = str(v)
+
+            if version == 'v1':
+                # v1: 不带换行符
+                final_val += k + ":" + value_str
+            elif version == 'v1_1':
+                # v1_1: 带换行符
+                final_val += k + ":" + value_str + '\n'
+            else:
+                # 默认v1_1
+                final_val += k + ":" + value_str + '\n'
+
+        return final_val
+
+    def check_expired(self, authcode_json: str) -> bool:
+        """
+        检查授权码是否过期
+
+        Args:
+            authcode_json: 授权码JSON字符串
+
+        Returns:
+            bool: 是否未过期
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            # 检查过期时间
+            if 'expired_time' in body:
+                expired_time_str = body['expired_time']
+                expired_dt = self._parse_datetime(expired_time_str)
+
+                if not expired_dt:
+                    return False
+
+                if datetime.now() > expired_dt:
+                    return False
+
+            # 检查生效时间
+            if 'effect_time' in body:
+                effect_time_str = body['effect_time']
+                effect_dt = self._parse_datetime(effect_time_str)
+
+                if not effect_dt:
+                    return False
+
+                if datetime.now() < effect_dt:
+                    return False
+
+            return True
+        except:
+            return False
+
+    def check_ip(self, authcode_json: str, client_ip: str) -> bool:
+        """
+        检查客户端IP是否在授权范围内
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            client_ip: 客户端IP地址
+
+        Returns:
+            bool: IP是否在授权范围内
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            if 'ip_range' not in body:
+                return True
+
+            ip_ranges = body['ip_range']
+            if not ip_ranges:
+                return False
+
+            # 转换为列表
+            if isinstance(ip_ranges, str):
+                ip_list = [ip.strip() for ip in ip_ranges.split(',')]
+            elif isinstance(ip_ranges, list):
+                ip_list = ip_ranges
+            else:
+                return False
+
+            # 支持通配符 "*"
+            if '*' in ip_list:
+                return True
+
+            # 检查IP是否在范围内
+            try:
+                client_ip_obj = ipaddress.ip_address(client_ip)
+            except:
+                return False
+
+            for ip_pattern in ip_list:
+                try:
+                    if '/' in ip_pattern:
+                        # CIDR格式
+                        ip_network = ipaddress.ip_network(ip_pattern, strict=False)
+                        if client_ip_obj in ip_network:
+                            return True
+                    else:
+                        # 精确匹配
+                        if str(client_ip_obj) == ip_pattern:
+                            return True
+                except:
+                    continue
+
+            return False
+        except:
+            return False
+
+    def check_machine_code(self, authcode_json: str, machine_code: str) -> bool:
+        """
+        检查机器码是否被授权
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            machine_code: 机器码
+
+        Returns:
+            bool: 机器码是否被授权
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            if 'machine_codes' not in body:
+                return True
+
+            codes = body['machine_codes']
+            if not codes:
+                return False
+
+            # 转换为列表
+            if isinstance(codes, str):
+                code_list = [c.strip() for c in codes.split(',')]
+            elif isinstance(codes, list):
+                code_list = codes
+            else:
+                return False
+
+            # 支持通配符 "*"
+            if '*' in code_list:
+                return True
+
+            return machine_code in code_list
+        except:
+            return False
+
+    def check_module(self, authcode_json: str, module_name: str) -> bool:
+        """
+        检查模块是否被授权
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            module_name: 模块名称
+
+        Returns:
+            bool: 模块是否被授权
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            if 'modules' not in body:
+                return True
+
+            modules = body['modules']
+            if not modules:
+                return False
+
+            # 转换为列表
+            if isinstance(modules, str):
+                module_list = [m.strip() for m in modules.split(',')]
+            elif isinstance(modules, list):
+                module_list = modules
+            else:
+                return False
+
+            # 支持通配符 "*"
+            if '*' in module_list:
+                return True
+
+            return module_name in module_list
+        except:
+            return False
+
+    def check_artifact(self, authcode_json: str, artifact_name: str) -> bool:
+        """
+        检查制品名称是否匹配
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            artifact_name: 制品名称
+
+        Returns:
+            bool: 制品是否被授权
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            if 'artifact' not in body:
+                return True
+
+            authorized_artifact = body['artifact']
+
+            # 支持通配符 "*"
+            if authorized_artifact == '*':
+                return True
+
+            return artifact_name == authorized_artifact
+        except:
+            return False
+
+    def check_version(self, authcode_json: str, version: str) -> bool:
+        """
+        检查版本是否被授权
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            version: 版本号
+
+        Returns:
+            bool: 版本是否被授权
+        """
+        try:
+            authcode_obj = json.loads(authcode_json)
+            body = authcode_obj.get('body', {})
+
+            if 'version' not in body:
+                return True
+
+            authorized_version = body['version']
+
+            # 支持通配符 "*"
+            if authorized_version == '*':
+                return True
+
+            return version == authorized_version
+        except:
+            return False
+
+    def validate_all(self, authcode_json: str, client_ip: str = None,
+                     machine_code: str = None, artifact: str = None,
+                     version: str = None, module: str = None) -> bool:
+        """
+        检查所有条件是否都满足
+
+        Args:
+            authcode_json: 授权码JSON字符串
+            client_ip: 客户端IP（可选）
+            machine_code: 机器码（可选）
+            artifact: 制品名称（可选）
+            version: 版本号（可选）
+            module: 模块名称（可选）
+
+        Returns:
+            bool: 所有条件是否都满足
+        """
+        # 基本验证
+        if not self.validate(authcode_json):
+            return False
+
+        # 检查时间
+        if not self.check_expired(authcode_json):
+            return False
+
+        # 检查IP
+        if client_ip and not self.check_ip(authcode_json, client_ip):
+            return False
+
+        # 检查机器码
+        if machine_code and not self.check_machine_code(authcode_json, machine_code):
+            return False
+
+        # 检查制品
+        if artifact and not self.check_artifact(authcode_json, artifact):
+            return False
+
+        # 检查版本
+        if version and not self.check_version(authcode_json, version):
+            return False
+
+        # 检查模块
+        if module and not self.check_module(authcode_json, module):
+            return False
+
+        return True
+
+    # ============= 私有方法 =============
+
+    def _parse_datetime(self, date_str: str) -> Optional[datetime]:
+        """解析日期时间字符串"""
+        if not date_str:
+            return None
+
+        # 尝试多种格式
+        formats = [
+            '%Y-%m-%dT%H:%M',           # ISO: 2026-01-26T09:23
+            '%Y-%m-%dT%H:%M:%S',        # ISO: 2026-01-26T09:23:45
+            '%Y-%m-%d %H:%M:%S',        # 标准: 2026-01-26 09:23:45
+            '%Y-%m-%d %H:%M',           # 标准: 2026-01-26 09:23
+            '%Y-%m-%d',                 # 日期: 2026-01-26
+        ]
+
+        for fmt in formats:
+            try:
+                return datetime.strptime(date_str, fmt)
+            except:
+                continue
+
+        return None

ctools/cipher/sm_util.py

@@ -9,7 +9,6 @@ sm2_crypt: sm2.CryptSM2 = None
 def init(private_key: str, public_key: str):
   global sm2_crypt
   if sm2_crypt is not None:
-    print('sm2 is already init!!!')
     return
   sm2_crypt = sm2.CryptSM2(private_key=private_key, public_key=public_key, asn1=True, mode=1)
 

ctools/ml/image_process.py

@@ -0,0 +1,121 @@
+import random
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+
+def preprocess(img, img_size):
+  mean = [0.485, 0.456, 0.406]
+  std = [0.229, 0.224, 0.225]
+  img = resize(img, img_size)
+  img = img[:, :, ::-1].astype('float32')  # RGB->BGR
+  img = normalize(img, mean, std)
+  img = img.transpose((2, 0, 1))  # hwc -> chw
+  #show_preprocess(img, mean, std)
+  return img[np.newaxis, :]
+
+
+def resize(img, target_size):
+  """
+  img: numpy.ndarray (H,W,3) BGR or RGB
+  return: numpy.ndarray (target_size, target_size, 3)
+  """
+  img = Image.fromarray(img)
+  img = img.resize((target_size, target_size), Image.BILINEAR)
+  return np.array(img)
+
+
+def normalize(img, mean, std):
+  img = img / 255.0
+  mean = np.array(mean)[np.newaxis, np.newaxis, :]
+  std = np.array(std)[np.newaxis, np.newaxis, :]
+  img -= mean
+  img /= std
+  return img
+
+
+def show_preprocess(chw_img, mean, std):
+  """
+  chw_img: (3, H, W), float32, normalized
+  """
+  img = chw_img.copy()
+  # 1. CHW -> HWC
+  img = img.transpose(1, 2, 0)
+  # 2. de-normalize
+  img = img * std + mean
+  img = img * 255.0
+  # 3. clamp + uint8
+  img = np.clip(img, 0, 255).astype(np.uint8)
+  Image.fromarray(img).show()
+
+
+def draw_bbox(img, result, threshold=0.5, save_name='res.jpg', scale_factor=None, im_size=320, class_names=None):
+  draw = ImageDraw.Draw(img)
+
+  if scale_factor is not None:
+    h_scale, w_scale = scale_factor[0]
+  else:
+    h_scale = w_scale = 1.
+
+  # 类别颜色随机但固定
+  category_colors = {}
+  if class_names is not None:
+    for cls in class_names:
+      category_colors[cls] = tuple(random.randint(0, 255) for _ in range(3))
+
+  # 字体
+  try:
+    font = ImageFont.truetype("arial.ttf", 15)
+  except:
+    font = ImageFont.load_default()
+
+  for res in result:
+    cat_id, score, bbox = res[0], res[1], res[2:]
+    if score < threshold:
+      continue
+
+    # 归一化 bbox -> 模型输入尺寸
+    xmin = bbox[0] * im_size
+    ymin = bbox[1] * im_size
+    xmax = bbox[2] * im_size
+    ymax = bbox[3] * im_size
+
+    # 模型输入尺寸 -> 原图
+    xmin = xmin / w_scale
+    xmax = xmax / w_scale
+    ymin = ymin / h_scale
+    ymax = ymax / h_scale
+
+    # 类别名和颜色
+    if class_names is not None:
+      class_name = class_names[int(cat_id)]
+      color = category_colors[class_name]
+      text = f"{class_name}:{score:.2f}"
+
+      # 获取文字尺寸，兼容所有版本 Pillow
+      try:
+        text_width, text_height = font.getsize(text)  # 旧版 / 大部分版本
+      except AttributeError:
+        # Pillow 9.2+ 推荐用 getbbox
+        bbox_font = font.getbbox(text)
+        text_width = bbox_font[2] - bbox_font[0]
+        text_height = bbox_font[3] - bbox_font[1]
+
+      text_origin = (xmin, max(0, ymin - text_height))  # 框上方显示
+      draw.text(text_origin, text, fill=color, font=font)
+    else:
+      color = 'red'
+
+    # 画矩形框
+    draw.rectangle([xmin, ymin, xmax, ymax], outline=color, width=2)
+
+  img.save(save_name)
+
+
+def image_show(base64_str):
+  """base64字符串转PIL Image并显示"""
+  from io import BytesIO
+  import base64
+  img_data = base64.b64decode(base64_str)
+  img = Image.open(BytesIO(img_data))
+  img.show()

ctools/ml/img_extractor.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2026/1/20 15:02'
+
+import base64
+from io import BytesIO
+
+class ClassRegionBase64ExtractorPIL:
+  def __init__(self, class_names, target_classes=None, threshold=0.5):
+    """
+    class_names: 模型类别列表
+    target_classes: 只截取的类别名列表，None 表示全部
+    threshold: 置信度阈值
+    """
+    self.class_names = class_names
+    self.target_classes = target_classes
+    self.threshold = threshold
+
+  @staticmethod
+  def image_to_base64(img, format='PNG'):
+    """
+    PIL Image -> base64 字符串
+    """
+    buffer = BytesIO()
+    img.save(buffer, format=format)
+    return base64.b64encode(buffer.getvalue()).decode('utf-8')
+
+  def extract(self, img, results, scale_factor=None, im_size=320):
+    """
+    img: PIL Image
+    results: 模型输出 [[cat_id, score, xmin, ymin, xmax, ymax], ...]
+    scale_factor: np.array([[h_scale, w_scale]]) 或 None
+    im_size: 模型输入尺寸
+    return: List[Dict] -> [{"class": class_name, "score": score, "base64": base64_str}, ...]
+    """
+    outputs = []
+    for res in results:
+      cat_id, score, bbox = res[0], res[1], res[2:]
+      if score < self.threshold or cat_id > len(self.class_names) - 1:
+        continue
+      class_name = self.class_names[int(cat_id)]
+      if self.target_classes is not None and class_name not in self.target_classes:
+        continue
+      xmin = bbox[0]
+      ymin = bbox[1]
+      xmax = bbox[2]
+      ymax = bbox[3]
+      # 裁剪
+      pil_img_threadsafe = img.copy()
+      cropped = pil_img_threadsafe.crop((xmin, ymin, xmax, ymax))
+      # 转 base64
+      b64_str = self.image_to_base64(cropped)
+      outputs.append({
+        "class": class_name,
+        "score": float(score),
+        "base64": b64_str
+      })
+    return outputs

ctools/ml/ppi.py

@@ -0,0 +1,275 @@
+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_and_extract(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)
+    return extractor.extract(pil_img, merged_detections, scale_factor=scale_factor, im_size=orig_h)

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)
@@ -120,7 +122,7 @@ 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)
 

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'
 

{gomyck_tools-1.5.4.dist-info → gomyck_tools-1.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gomyck-tools
-Version: 1.5.4
+Version: 1.5.6
 Summary: A tools collection for python development by hao474798383
 Author-email: gomyck <hao474798383@163.com>
 License-Expression: Apache-2.0
@@ -45,6 +45,8 @@ Requires-Dist: scikit-learn>=1.7.1; extra == "ml"
 Requires-Dist: pandas>=2.3.2; extra == "ml"
 Requires-Dist: lxml>=6.0.1; extra == "ml"
 Requires-Dist: xlrd>=2.0.2; extra == "ml"
+Provides-Extra: xj-plate-server
+Requires-Dist: paddlepaddle==3.2.2; extra == "xj-plate-server"
 Dynamic: license-file
 
 # Gomyck-Tools

{gomyck_tools-1.5.4.dist-info → gomyck_tools-1.5.6.dist-info}/RECORD

@@ -1,6 +1,7 @@
 ctools/__init__.py,sha256=7EtnbO7mi1iYQeyU4CLusYrwO96_dC7eR7jboyWAqvg,1089
 ctools/application.py,sha256=QFLbwmjznz2HAwVyph9PhzMpJUU5R82eMaVcw5UDSMk,15899
 ctools/aspect.py,sha256=lXrpeu_F3w6v2Hu2yOwQIRGqfDN25_H-1YyW6fPt_mw,1667
+ctools/authcode_validator.py,sha256=g-AFBCEVvtLaoRTXn4qZgVfMv3TUFFYFUmc4fn8Hps8,12312
 ctools/call.py,sha256=TFFC8PqvCu0PS0XelmV4QXdXezQiUsEacxg3RgKvdwE,1572
 ctools/cdate.py,sha256=OhKAaQfo2Rxd3Jx3g9AfPsaISRoLkstqZdaGT4ZZr_I,3096
 ctools/cdebug.py,sha256=_mihZRCEx_bi7Kv_QPjP4MPLNFrl-GR1Y_irTgOP7OU,4021
@@ -14,7 +15,7 @@ ctools/patch.py,sha256=2eIle4uVTIcy1QMB1LbApo47cQTJ8GnXMihp-Mkgse0,3128
 ctools/path_info.py,sha256=JoEGPeeSu1jMGTIquq2CZFMe7Ergg8gL4DPt3_Q4q0U,2688
 ctools/similar.py,sha256=ByOFaJ2AHZBe3ekoEco5miXcZP1XW7vGecH1i3dES5g,698
 ctools/sys_info.py,sha256=QynB_2nQeGUuUdqJQldtEq916gDfPBsei1OWx9GYKSI,4278
-ctools/sys_log.py,sha256=Sud91NQEVIiqiW6zffv-LrdmVKqva9ijUpdhTxrQhDA,2782
+ctools/sys_log.py,sha256=zFXOuq6R5qimMfN0fovsyKgblLRJql9ZQLiThW1HJk4,3961
 ctools/ai/__init__.py,sha256=gTYAICILq48icnFbg0HCbsQO8PbU02EDOQ0JeMvfqTY,98
 ctools/ai/llm_chat.py,sha256=vgv1C72fv7YEGj_203L6JY_PyDszxvhrlLjLYbxuvZk,9133
 ctools/ai/llm_client.py,sha256=0xHvSQoAd4PAnunyH2a-cJ9RKTkWO1cFyrnqmA1j3g0,6178
@@ -41,12 +42,15 @@ ctools/cipher/b64.py,sha256=TLVYRCZc4BowPGk-RoSz89o9mqpDmFW8IlceP_KNZcI,196
 ctools/cipher/czip.py,sha256=7zNaafiG-O6NkaSv4cBP8jxUBqCTmCmPsd6efX0bu9Y,4679
 ctools/cipher/rsa.py,sha256=7TPwlt-JQxDVHwvL_Am9ZKI70B2CfJDqQDf473edHSQ,2264
 ctools/cipher/sign.py,sha256=i__5PVevvR2-VjJyInmyH1QJOpmuxcA9ZIM0oxxFWVo,567
-ctools/cipher/sm_util.py,sha256=cC58wZ9IL08SvUfWUNjX5139fal2SnXGaFQ0R9WA3SE,1675
+ctools/cipher/sm_util.py,sha256=vqECjsD7nLccQqnito_AyFm3WmlXdMS3yd_vnVZdt5w,1639
 ctools/database/__init__.py,sha256=fB36UC93Pya_1YyWGMzDy3D4tMDTBQoYK20E4wgNqec,98
 ctools/database/database.py,sha256=IQzPw2fOJh0Xn_OdSMeEOXBEV9YCRDoszg-dwJPXTTU,7765
 ctools/geo/__init__.py,sha256=OkUaZv5ckkXJFNbRyFZqkX5m3GxTueEGEBU99_jJQNE,98
 ctools/geo/coord_trans.py,sha256=UWCU1wnrTDU1aLSVAwmiHOeH7Pu-Dp8lDLAngDG48NM,3761
 ctools/geo/douglas_rarefy.py,sha256=bJo6TwNxPa-7-8MOi8MULxeqnz4cvIJN-oXqBDWNAVM,4883
+ctools/ml/image_process.py,sha256=keiIbcCkCZq-dp3PBpI-8tHFXNqKJKXATcrojMEpAGs,3168
+ctools/ml/img_extractor.py,sha256=x_o3il6gWoKMBRgJ9m7HNt70nY3Etr5QcPzEKq76oiA,1829
+ctools/ml/ppi.py,sha256=BtYam72ovii7UZ4LniM0smLv2fMmeqBUfKpfJTrHMVM,10886
 ctools/office/__init__.py,sha256=wum34b8YJg0qD7uKdDEbozSE8RIxWqTVa44CCIZyqPU,98
 ctools/office/cword.py,sha256=bIthKmf0oBqjcdkrU5hFDAPp66ZrjeMNzjIxOlMPeCc,837
 ctools/office/word_fill.py,sha256=ZoTxz0-agEy5atIRWqYmQZz82nVr2zz9JebSTMkulIo,18214
@@ -69,20 +73,20 @@ ctools/util/env_config.py,sha256=L98G9LPdpD7Yl5XbA_-KfkcA4mDunQoKiYtK5w7QR-s,179
 ctools/util/html_soup.py,sha256=rnr8M3gn3gQGo-wNaNFXDjdzp8AAkv9o4yqfIIfO-zw,1567
 ctools/util/http_util.py,sha256=cx0FRnPLFdJ0mF9UYphl40SZj68fqG30Q0udku9hZIE,769
 ctools/util/image_process.py,sha256=nqJOi2p8wLe8wRsfkH99MyEYSjE9i4fthxBJwrrZVB8,835
-ctools/util/jb_cut.py,sha256=2vs054_lM-0sxh70cUv7nHhLkWW1ioM3MQ5LF25sBl8,1844
+ctools/util/jb_cut.py,sha256=ZMj5QV031sersGzd8xrO_LihqnyeEGud6fFwJQIGwGo,1833
 ctools/util/snow_id.py,sha256=KCuQ0zOTlmus8gZetmRA5y0jBSd8J0KXcJ33EzgCKjE,2225
 ctools/web/__init__.py,sha256=koSNYeKF5Z_xbp4Q2qbZ4ZP-3--1phbOYN9e4SJy_gk,98
 ctools/web/aio_web_server.py,sha256=p46BOU3_m4Jb57yAACeedKjhlFc1YC0QJSUe2selBgA,5693
 ctools/web/api_result.py,sha256=i1MjTnnlgkWl_q07xr-TLQeLYlXEh4DEclUFE414nSk,1568
-ctools/web/bottle_web_base.py,sha256=iQZJtRQH3HJ-P-48Gspvp1VEd6boAlZfiat3H8E5bBU,8763
-ctools/web/bottle_webserver.py,sha256=9IcmQ8dHtbR7VW29sqZ_NM954KNf-V_Z6rJZ4pnz4P4,7169
-ctools/web/bottle_websocket.py,sha256=xsu9fAtTuR5DsSsQjiBfaYxLjOWFyfr1sYM6cktTovI,1957
-ctools/web/ctoken.py,sha256=WaB29kqGlKAh21aUw5avl2h8AgLD1aESw8KCpqaN5nM,2539
+ctools/web/bottle_web_base.py,sha256=DWqvS7-_BRP_ojGWmFeIGfdXVfeuhcptVb7qxl4MO6c,8781
+ctools/web/bottle_webserver.py,sha256=k4p-ji3VGvU8jCO9NBx-nIbEOmAxXbBo9sYQKrOwtCM,7225
+ctools/web/bottle_websocket.py,sha256=cVNGnTs1ej1iDRkLiA_EUklydfC7ZHiiU_DzL2RHgtY,1972
+ctools/web/ctoken.py,sha256=qsxrQY7IWgpPe5HyiDDnf50vsRX27QXMWPzam7bGu_Y,2646
 ctools/web/download_util.py,sha256=v0JTXiED1bvoWFfwfd-LD5s7_aoRQ0lCkaGwSnSp7WI,1954
 ctools/web/params_util.py,sha256=eJDV3PSq-ZHb8UZf6xqs8kOhbyZzits1H9yPoUBIDXg,828
 ctools/web/upload_util.py,sha256=z1QQCi4SFx08jrAQH5-Y_ShiM4MghuD_5Qz6V9KK_4U,1076
-gomyck_tools-1.5.4.dist-info/licenses/LICENSE,sha256=X25ypfH9E6VTht2hcO8k7LCSdHUcoG_ALQt80jdYZfY,547
-gomyck_tools-1.5.4.dist-info/METADATA,sha256=byhNUGqMt6IFVmf5ROsxNuuK3ST4fjcPTKqZa8pzuC4,1862
-gomyck_tools-1.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gomyck_tools-1.5.4.dist-info/top_level.txt,sha256=-MiIH9FYRVKp1i5_SVRkaI-71WmF1sZSRrNWFU9ls3s,7
-gomyck_tools-1.5.4.dist-info/RECORD,,
+gomyck_tools-1.5.6.dist-info/licenses/LICENSE,sha256=X25ypfH9E6VTht2hcO8k7LCSdHUcoG_ALQt80jdYZfY,547
+gomyck_tools-1.5.6.dist-info/METADATA,sha256=bzC0W0VinVmWDxCSpMkw5elRZ2svLnrog1aHUehGFFA,1957
+gomyck_tools-1.5.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gomyck_tools-1.5.6.dist-info/top_level.txt,sha256=-MiIH9FYRVKp1i5_SVRkaI-71WmF1sZSRrNWFU9ls3s,7
+gomyck_tools-1.5.6.dist-info/RECORD,,

{gomyck_tools-1.5.4.dist-info → gomyck_tools-1.5.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any