jit-utils-backend 0.0.1__py3-none-any.whl

jit_utils/matchTool.py

@@ -0,0 +1,136 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2023/7/12
+
+@author: 臧韬
+
+@desc: 默认描述
+"""
+import copy
+from abc import ABCMeta, abstractmethod
+
+
+class BaseMatchRole(metaclass=ABCMeta):
+    successMsg = ""
+
+    @abstractmethod
+    def hash(self, data) -> int:
+        """
+        将 Dict 数据按照自定义的方式进行hash，返回一个hash int
+        如果这里返回的是None，则被认为不合格数据，将不进行匹配
+        """
+        pass
+
+
+class MatchResultNumEnum:
+    success = 0
+    oldOnly = -1
+    newOnly = 1
+
+
+# 这个的 作用是 给MatchTool.match返回值 构建返回 数据
+class MatchResult(object):
+    DEFAULT_SUCCESS_RESULT_STRING = "匹配成功"
+    DEFAULT_OLD_ONLY_RESULT_STRING = "只有旧数据匹配"
+    DEFAULT_NEW_ONLY_RESULT_STRING = "只有新数据匹配"
+
+    def __init__(self, oldData=None, newData=None, resultStr=None):
+        self.oldData = oldData
+        self.newData = newData
+        self.resultStr = resultStr
+
+    @property
+    def resultNum(self):
+        if self.oldData and self.newData:
+            return MatchResultNumEnum.success
+        if self.oldData:
+            return MatchResultNumEnum.oldOnly
+        if self.newData:
+            return MatchResultNumEnum.newOnly
+
+    @property
+    def matchResultStr(self):
+        if self.resultStr:
+            return self.resultStr
+        if self.resultNum == MatchResultNumEnum.success:
+            return self.DEFAULT_SUCCESS_RESULT_STRING
+        if self.resultNum == MatchResultNumEnum.oldOnly:
+            return self.DEFAULT_OLD_ONLY_RESULT_STRING
+        if self.resultNum == MatchResultNumEnum.newOnly:
+            return self.DEFAULT_NEW_ONLY_RESULT_STRING
+        return "未知错误"
+
+    def toDict(self):
+        return {
+            "oldData": self.oldData,
+            "newData": self.newData,
+            "resultStr": self.resultStr,
+            "matchResultStr": self.matchResultStr,
+        }
+
+    def __repr__(self):
+        return "<{} {}>".format(self.__class__.__name__, self.matchResultStr)
+
+
+class MatchHashData(object):
+    def __init__(self, data, hashList=None):
+        self.data = data
+        self.hashList = hashList
+
+
+class MatchTool(object):
+    """
+    匹配工具，自定义匹配规则，只要有一个匹配成功，则算匹配成功。
+    """
+
+    matchRoles = []
+    matchResultCls = MatchResult
+
+    @classmethod
+    def match(cls, oldList: list, newList: list):
+        # 避免污染数据源
+        oldList = copy.deepcopy(oldList)
+        newList = copy.deepcopy(newList)
+
+        result = []
+        # 循环是判断匹配规则，可能会thirdDeptId 等多个匹配规则 或判断
+        for matchRole in cls.matchRoles:
+            oldHashMap = cls.getHashMap(oldList, matchRole())
+            newHashMap = cls.getHashMap(newList, matchRole())
+            hashSet = set(oldHashMap.keys()) | set(newHashMap.keys())
+            for h in hashSet:
+                oldData = oldHashMap.get(h)
+                newData = newHashMap.get(h)
+                if oldData and newData:
+                    # 匹配成功，只要匹配成功，这个数据就不用进行下个匹配规则
+                    oldHashMap.pop(h)
+                    newHashMap.pop(h)
+                    result.append(cls.matchResultCls(oldData, newData, matchRole.successMsg))
+
+            # 通过一次匹配规则后，将已经匹配的数据对从列表中删除
+            oldList = list(oldHashMap.values())
+            newList = list(newHashMap.values())
+
+        # 经过所有匹配规则中，将未匹配到的数据也加到匹配结果中
+        for oldData in oldList:
+            # 只有老数据，没有新数据匹配
+            result.append(cls.matchResultCls(oldData=oldData))
+
+        for newData in newList:
+            # 只有新数据，没有老数据匹配
+            result.append(cls.matchResultCls(newData=newData))
+
+        return result
+
+    @classmethod
+    def getHashMap(cls, dataList, matchRole: BaseMatchRole) -> dict:
+        """
+        将多个数据，按照hash规则转换成map
+        """
+        hashMap = {}
+        for data in dataList:
+            h = matchRole.hash(data)
+            if h is None:
+                h = hash(str(data))
+            hashMap.setdefault(h, data)
+        return hashMap

jit_utils/network.py

@@ -0,0 +1,36 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2024/10/31 11:08
+
+@author: 'wuhao'
+
+@desc:
+"""
+import socket
+
+
+def checkConnect(host, port, timeout=0.3):
+    """
+    检查ip和端口是否合法
+    :param ip:
+    :param port:
+    :return:
+    """
+    try:
+        port = int(port)
+    except ValueError:
+        return False
+    if not (0 <= port <= 65535):
+        return False
+    if host.startswith("127") and host != "127.0.0.1":
+        return False
+    # 检查ip port 是否开启
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.settimeout(timeout)
+    try:
+        s.connect((host, port))
+        return True
+    except:  # noqa E722
+        return False
+    finally:
+        s.close()

jit_utils/qrcode.py

@@ -0,0 +1,60 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2025/01/21
+
+@author: 臧韬
+
+@desc: 二维码工具，暂时用于文件渲染
+"""
+import base64
+from io import BytesIO
+
+import qrcode
+
+
+class Qrcode(object):
+    """
+    二维码模块，暂用于文件渲染
+    """
+
+    DEFAULT_ROW = 200
+    DEFAULT_COL = 200
+    DEFAULT_BOX_SIZE = 10
+    DEFAULT_BORDER = 4
+
+    def __init__(self, value: str, row=None, col=None):
+        self.value = value
+        # self.boxSize = boxSize or self.DEFAULT_BOX_SIZE
+        # self.border = border or self.DEFAULT_BORDER
+        self.row = row or self.DEFAULT_ROW
+        self.col = col or self.DEFAULT_COL
+
+    def toByte(self):
+        file = self.toFile()
+        data = file.read()
+        return data
+
+    def toFile(self):
+        qr = qrcode.QRCode(
+            version=1,
+            error_correction=qrcode.constants.ERROR_CORRECT_L,
+            box_size=self.DEFAULT_BOX_SIZE,
+            border=self.DEFAULT_BORDER,
+        )
+        # 添加数据
+        qr.add_data(self.value)
+        qr.make(fit=True)
+        img = qr.make_image(fill_color="black", back_color="white")
+        img._img = img.get_image().resize((self.row, self.col))
+        imgBytes = BytesIO()
+        img.save(imgBytes)
+        imgBytes.seek(0)
+        return imgBytes
+
+    def toStr(self):
+        if not self.value:
+            return ""
+        return "<image:{}>".format(base64.b64encode(self.toByte()).decode("utf-8"))
+
+    def __str__(self):
+        return self.toStr()

jit_utils/signature.py

@@ -0,0 +1,56 @@
+"""
+Created on 2024/8/14 14:24
+
+@author: 'wuhao'
+
+@desc:
+"""
+
+import base64
+import hashlib
+import json
+from decimal import Decimal
+
+
+def formatNumber(obj):
+    if isinstance(obj, (float, int)) and not isinstance(obj, bool):
+        # 保证不使用科学计数法，保留 10 位精度
+        obj = Decimal(str(obj))
+        return format(obj, ".32f").rstrip("0").rstrip(".")
+    elif isinstance(obj, dict):
+        return {k: formatNumber(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [formatNumber(i) for i in obj]
+    else:
+        return obj
+
+
+def uniqueParams(paramDict, signKey="sign"):
+    parmList = []
+    for key in sorted(paramDict.keys(), reverse=True):
+        if key == signKey:
+            continue
+        parmList.append("{key}{val}".format(key=key, val=paramDict[key]))
+    return "".join(parmList), len(parmList)
+
+
+def generateSignature(string, interval, divisor=1.4):
+    signString = hashlib.sha1(base64.b64encode(bytes(string, encoding="utf-8"))).hexdigest()
+    signStringLen = len(signString)
+    sampleCount = int(interval * divisor)
+    if sampleCount >= signStringLen:
+        return signString
+    cycle = int(signStringLen / sampleCount)
+    rr = "".join(signString[int(i * cycle)] for i in range(sampleCount))
+    return rr
+
+
+def getSign(paramDict):
+    paramDict = formatNumber(paramDict)
+    for k, v in paramDict.items():
+        if isinstance(v, (list, dict)):
+            paramDict[k] = json.dumps(v, ensure_ascii=False, separators=(",", ":"))
+        else:
+            paramDict[k] = v
+    uString, lenValue = uniqueParams(paramDict)
+    return generateSignature(uString, lenValue)

jit_utils/spaceSender.py

@@ -0,0 +1,44 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2024/04/28
+
+@author: 臧韬
+
+@desc: 默认描述
+"""
+import requests
+
+from .signature import getSign
+from .time import getTimestamp
+
+
+class SpaceSender:
+    @classmethod
+    def sendApi(cls, entry, appId, element: str, func: str, argDict: dict, headers: dict = None):
+        """
+        myapp之间接口转发
+        :param entry: 请求入口
+        :param appId: 发送给哪个app
+        :param element: 元素的fullName(通常是svc)
+        :param func: 具体调用的函数
+        :param argDict: 具体请求数据
+        :param headers: 具体请求头
+        :return:
+        """
+        path = "/api/{appId}/{element}/{func}".format(
+            appId=appId.replace(".", "/"), element=element.replace(".", "/"), func=func
+        )
+        headers = headers or {}
+        url = "{entry}{path}".format(entry=entry, path=path)
+        token = headers.get("token", "")
+        timestamp = str(getTimestamp())
+        paramDict = {"path": path, "token": token, "timestamp": timestamp, **argDict}
+        sign = getSign(paramDict)
+        headers["sign"] = sign
+        headers["timestamp"] = timestamp
+        headers["Domain"] = entry
+        response = requests.post(url, json=argDict, headers=headers)
+        if response.status_code != 200:
+            raise Exception("请求失败")
+        respJson = response.json()
+        return respJson

jit_utils/string.py

@@ -0,0 +1,118 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2023/10/25 20:04
+
+@author: 'wuhao'
+
+@desc: 简单说明
+"""
+import hashlib
+import math
+import os
+import random
+import re
+import string
+import uuid
+
+CHARS = string.ascii_letters + string.digits
+
+
+def randomString(size=8):
+    chars = random.choices(CHARS, k=size)
+    return "".join(chars)
+
+
+def randomNum(size=6):
+    """生成随机6位数字，用于手机号验证码"""
+    num = "%0{}d".format(size) % random.randint(0, 10**size - 1)
+    return num
+
+
+def getUuidStr():
+    return str(uuid.uuid4()).replace("-", "")
+
+
+def md5Bytes(b):
+    """
+    md5加密
+    :param b: 文件的二进制数据
+    :return: str: md5字符串
+    """
+    return hashlib.md5(b).hexdigest()
+
+
+def md5Str(normalStr, encodeType="utf-8"):
+    """
+    md5加密
+    :param normalStr: 普通python字符串
+    :param encodeType: 编码方式
+    :return str: md5字符串
+    """
+    return md5Bytes(normalStr.encode(encodeType))
+
+
+def lowercase(name):
+    if not name:
+        return ""
+    return name[0].lower() + name[1:]
+
+
+def capitalize(name):
+    if not name:
+        return ""
+    return name[0].upper() + name[1:]
+
+
+def getFileMd5(filename):
+    if not os.path.isfile(filename):
+        return
+    myhash = hashlib.md5()
+    f = open(filename, "rb")
+    while True:
+        b = f.read(4096)
+        if not b:
+            break
+        myhash.update(b)
+    f.close()
+    return myhash.hexdigest()
+
+
+def getRandomField(k=4):
+    character = string.ascii_lowercase + string.digits
+    charArray = random.choices(character, k=k)
+    res = "fk" + "".join(charArray)
+    return res
+
+
+def getRandom(k=8):
+    character = string.ascii_lowercase + string.digits
+    charArray = random.choices(character, k=k)
+    return "".join(charArray)
+
+
+def genrSublist(orgList, sliceSize):
+    """
+    for tempList in genrSublist(range(20), 5):
+        print(tempList)
+
+    [0, 1, 2, 3, 4]
+    [5, 6, 7, 8, 9]
+    [10, 11, 12, 13, 14]
+    [15, 16, 17, 18, 19]
+    """
+    sliceCount = int(math.ceil(len(orgList) / float(sliceSize)))
+    for i in range(sliceCount):
+        yield orgList[i * sliceSize : (i + 1) * sliceSize]
+
+
+def renderTemplateString(source, **context):
+    # 使用正则表达式查找所有的变量 {{var_name}}
+    pattern = r"\{\{(\w+)\}\}"
+
+    def replaceVar(match):
+        var_name = match.group(1)  # 获取变量名
+        return str(context.get(var_name, ""))  # 从上下文中获取变量值，如果不存在则返回空字符串
+
+    rendered = re.sub(pattern, replaceVar, source)
+
+    return rendered