gomyck-tools 1.5.3__py3-none-any.whl → 1.5.5__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/database/database.py

@@ -1,11 +1,9 @@
 import contextlib
 import datetime
 import math
-import threading
 
-from sqlalchemy import create_engine, BigInteger, Column, event
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy import create_engine, BigInteger, Column
+from sqlalchemy.orm import sessionmaker, Session, declarative_base
 from sqlalchemy.sql import text
 
 from ctools import call
@@ -14,17 +12,37 @@ from ctools.pools.thread_pool import thread_local
 from ctools.web.bottle_web_base import PageInfo
 
 """
+from time import sleep
+
+from sqlalchemy import text, Column, BigInteger, String
+
+from ctools import cid, cjson
+from ctools.database import database
+from ctools.database.database import BaseMixin
+
 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()
+database.init_db('postgresql://postgres:Hylink2014%40postgres@192.168.3.127:31199/postgres', default_schema='public', db_key='source', pool_size=100, auto_gen_table=True)
+while True:
+  with database.get_session('source') as s:
+    params = {
+      'obj_id': cid.get_snowflake_id(),
+      'server_ip': cid.get_random_str(5),
+      'user_id': 123,
+      'server_content': cid.get_random_str(5),
+    }
+    s.execute(text('insert into t_xxx_info (obj_id, server_ip, user_id) values (:obj_id, :server_ip, :user_id)'), params)
+    s.commit()
+    sleep(0.2)
+    res = s.query(XXXX.obj_id, XXXX.server_ip, XXXX.user_id).all()
+    for item in res:
+      print(item._asdict())
+    print(len(res))
+  sleep(1)
 """
 
 Base = None

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