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

jit_utils/config/field.py

@@ -0,0 +1,177 @@
+# -*-coding:utf-8-*-
+
+"""
+Created on 2023/9/20
+
+@author: 臧韬
+
+@desc: 默认描述
+"""
+from commons.utils.config.exception import TlConfigException
+
+
+class NoneType(object):
+    def __bool__(self):
+        return False
+
+
+class AnyType(object):
+    pass
+
+
+class Inf(float):
+    __instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__instance is None:
+            cls.__instance = super(Inf, cls).__new__(cls, "inf")
+        return cls.__instance
+
+    def __gt__(self, other):
+        return False
+
+    def __str__(self):
+        return "无穷大"
+
+    def __neg__(self):
+        return NegInf()
+
+    def __invert__(self):
+        return NegInf()
+
+    def __floordiv__(self, other):
+        return self
+
+    def __truediv__(self, other):
+        return self
+
+
+class NegInf(float):
+    __instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls.__instance is None:
+            cls.__instance = super(NegInf, cls).__new__(cls, "-inf")
+        return cls.__instance
+
+    def __gt__(self, other):
+        return True
+
+    def __str__(self):
+        return "无穷小"
+
+    def __neg__(self):
+        return Inf()
+
+    def __invert__(self):
+        return Inf()
+
+
+inf = Inf()
+
+# print("<<<<<<<<<<<<<基类被加载")
+
+
+class Field(object):
+    """
+    这是一个基类字段
+    """
+
+    def __init__(self, argType=AnyType, required=True, default=None, checkFunc=None, transformFunc=None):
+        self.argType = argType
+        # 当一个字段设置了默认值，那么设置成必传就没有意义
+        self.required = False if default else required
+        self.default = default
+        self.checkFunc = checkFunc
+        self.transformFunc = transformFunc
+
+        self.name = None
+
+    def check(self, value):
+        if self.required and value is None:
+            raise TlConfigException("该字段必传! field={f}".format(f=self.name))
+        if self.argType is not AnyType and not isinstance(value, self.argType):
+            raise TlConfigException(
+                "该参数应该传入的数据类型是={at}, 收到的数据类型={vt}! 值={v}, 字段名={f}".format(
+                    at=self.argType.__name__, vt=type(value).__name__, v=str(value), f=self.__class__.__name__
+                )
+            )
+        if callable(self.checkFunc):
+            self.checkFunc(value)
+
+    def transform(self, value):
+        if value is NoneType:
+            return value
+        if callable(self.transformFunc):
+            try:
+                return self.transformFunc(value)
+            except Exception as e:
+                raise e
+        return value
+
+
+# print("Field: {}".format(id(Field)))
+
+
+class StringField(Field):
+    """
+    字符串字段
+    """
+
+    DEFAULT_MAX_LEN = 65535
+    DEFAULT_MIN_LEN = 0
+
+    def __init__(
+        self,
+        argType=str,
+        required=True,
+        default=None,
+        maxLen=DEFAULT_MAX_LEN,
+        minLen=DEFAULT_MIN_LEN,
+        transformFunc=str,
+    ):
+        super(StringField, self).__init__(
+            argType=argType, required=required, default=default, checkFunc=self.stringCheck, transformFunc=transformFunc
+        )
+
+        self.maxLen = maxLen
+        self.minLen = minLen
+
+    def lengthCheck(self, value, maxLen, minLen):
+        if minLen == maxLen and len(value) != minLen:
+            raise TlConfigException("{name}的长度应该是 {minLen}".format(name=self.name, minLen=minLen))
+        if not minLen <= len(value) <= maxLen:
+            raise TlConfigException(
+                "{name}的长度必须介于 {minLen} 到 {maxLen} 之前".format(name=self.name, minLen=minLen, maxLen=maxLen)
+            )
+
+    def stringCheck(self, value):
+        self.lengthCheck(value, maxLen=self.maxLen, minLen=self.minLen)
+
+
+class IntField(Field):
+    DEFAULT_MAX_NUM = inf
+    DEFAULT_MIN_NUM = -inf
+
+    def __init__(self, argType=int, required=True, maxNum=DEFAULT_MAX_NUM, minNum=DEFAULT_MIN_NUM, default=None):
+        super(IntField, self).__init__(
+            argType=argType, required=required, default=default, checkFunc=self.intCheck, transformFunc=self.toInt
+        )
+
+        self.maxNum = maxNum
+        self.minNum = minNum
+
+    def rangeCheck(self, value, maxNum, minNum):
+        if not minNum <= value <= maxNum:
+            raise TlConfigException(
+                "{name} 的取值范围是 {minNum} 到 {maxNum}".format(name=self.name, minNum=minNum, maxNum=maxNum)
+            )
+
+    def toInt(self, value):
+        if isinstance(value, str):
+            if not value.isnumeric():
+                raise TlConfigException("{name} 必须传入数字".format(name=self.name))
+        return int(value)
+
+    def intCheck(self, value):
+        self.rangeCheck(value=value, maxNum=self.maxNum, minNum=self.minNum)

jit_utils/convert.py

@@ -0,0 +1,169 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2022/12/27
+
+@author: lyon
+
+@desc:
+"""
+
+from jit.commons.utils.logger import log
+
+
+class Converter(object):
+
+    def __init__(self):
+        self._globals = {}
+
+    def getFuncSubClasses(self, baseCls):
+        for subCls in baseCls.__subclasses__():
+            if hasattr(subCls, "function"):
+                self._globals[subCls.function] = subCls
+            self.getFuncSubClasses(subCls)
+
+    def getExprSubClasses(self, baseCls):
+        for subCls in baseCls.__subclasses__():
+            self._globals[subCls.__name__] = subCls
+            self.getExprSubClasses(subCls)
+
+    def eval(self, expression):
+        # t表达式里面有 "T(modelPath)xxx"
+        # 加载FUNC子类
+        from models.Meta import Expression
+
+        self.getExprSubClasses(Expression)
+        Sql = app.getElement("globals.Sql")
+        self._globals["Calc"] = Sql
+        self._globals["null"] = None
+        return eval(expression, self._globals)
+
+
+converter = Converter()
+
+
+class MemoryCompiler(object):
+    """
+    Q表达式内存计算判断
+    """
+
+    def __init__(self, expression, data=None):
+        self.expression = expression
+        self.data = data
+
+    def parse(self):
+        from models.Meta import Func
+
+        if isinstance(self.expression, Func):
+            result = FuncParser(self.expression).getMemory(self)
+        else:
+            # 根据类名选择对应的解析器(解析器需要我们自己手动去完成构建)
+            Parser = globals()[self.expression.__class__.__name__ + "Parser"]
+            result = Parser(self.expression).getMemory(self)
+        return result
+
+    def evalQ(self):
+        try:
+            result = self.parse()
+            return converter.eval("lambda x: %s" % result)(self.data)
+        except Exception as e:
+            log.error(e)
+            return False
+
+
+class ExpressionParser(object):
+
+    def __init__(self, *args, **kwargs):
+        self.quoteCache = {"*": "*"}
+
+    def getMemory(self, compiler):
+        raise NotImplementedError
+
+
+class QParser(ExpressionParser):
+    """
+    Q表达式解析
+    """
+
+    def __init__(self, q):
+        super(QParser, self).__init__(q)
+        self.q = q
+
+    def getMemory(self, compiler):
+        from models.Meta import QAND, QOR, getLookup
+
+        result = []
+        if self.q.sourceExpressions:
+            # 嵌套结构
+            for expr in self.q.sourceExpressions:
+                if isinstance(expr, (QAND, QOR)):
+                    result.append(expr())
+                else:
+                    result.append(self.__class__(expr).getMemory(compiler))
+        else:
+            # 非嵌套结构
+            lookup = getLookup(self.q.compareName)
+            if lookup:
+                result.append(LookupParser(lookup(self.q.lhs, self.q.rhs)).getMemory(compiler))
+        return "({})".format(" ".join(result))
+
+
+class LookupParser(ExpressionParser):
+
+    def __init__(self, lookup):
+        super(LookupParser, self).__init__(lookup)
+        self.lookup = lookup
+
+    def getMemory(self, compiler):
+        ls = MemoryCompiler(self.lookup.lhs, compiler.data).parse()
+        rs = MemoryCompiler(self.lookup.rhs, compiler.data).parse()
+        if "{ls}" in self.lookup.memory:
+            return self.lookup.memory.format(ls=ls, rs=rs)
+        return "(%s %s %s)" % (ls, self.lookup.memory, rs)
+
+
+class FuncParser(ExpressionParser):
+
+    def __init__(self, func):
+        super(FuncParser, self).__init__(func)
+        self.func = func
+
+    def getMemory(self, compiler):
+        exps = [str(MemoryCompiler(exp, compiler.data).parse()) for exp in self.func.sourceExpressions]
+        return "%s(%s)" % (self.func.memory, ", ".join(exps))
+
+
+class FParser(ExpressionParser):
+
+    def __init__(self, f):
+        super(FParser, self).__init__(f)
+        self.f = f
+
+    def getMemory(self, compiler):
+        """
+        如果有数据, 就返回值
+        没有, 就返回 x.字段
+        """
+        # TODO: 暂时先只做一层
+        return repr(compiler.data.get(self.f.fieldId, "x.%s" % self.f.fieldId))
+
+
+class ValueParser(ExpressionParser):
+
+    def __init__(self, value):
+        super(ValueParser, self).__init__(value)
+        self.value = value
+
+    def getMemory(self, compiler):
+        return repr(self.value.value)
+
+
+class CombinedExpressionParser(ExpressionParser):
+
+    def __init__(self, combine):
+        super(CombinedExpressionParser, self).__init__(combine)
+        self.combine = combine
+
+    def getMemory(self, compiler):
+        left = MemoryCompiler(self.combine.lhs, compiler.data).parse()
+        right = MemoryCompiler(self.combine.rhs, compiler.data).parse()
+        return "(%s %s %s)" % (left, self.combine.connector, right)

jit_utils/decorator.py

@@ -0,0 +1,58 @@
+import inspect
+import json
+
+import requests
+
+
+def forward(fullName):
+    def inner(func):
+        def wrapper(self, *args, **kwargs):
+            appRule = app.env.getRuleByAppId(app.appId)
+            # 当前APP, 不需要转发
+            authApp = appRule.variables.get("authApp")
+            if not authApp:
+                return func(self, *args, **kwargs)
+            else:
+                if not app.env.envEntryList:
+                    raise Exception("无环境入口")
+                entry = app.domain
+                uri = "{}/api/{}/{}/{}".format(
+                    entry.strip("/"), authApp.replace(".", "/"), fullName.replace(".", "/"), func.__name__
+                )
+                argDict = {}
+                f = inspect.getfullargspec(func)
+                fargs = f.args
+                fargs.pop(0)
+                for key, value in zip(fargs, args):
+                    argDict[key] = value
+                if len(args) > len(f.args):
+                    argDict[f.varargs] = args[len(f.args) - 1 :]
+                for key, value in kwargs.items():
+                    argDict[key] = value
+
+                argDict = {"argDict": argDict}
+
+                # 这里headers要把Token传过去
+                try:
+                    argDict = json.dumps(argDict)
+                    response = requests.post(
+                        uri,
+                        data=argDict,
+                        headers={"Content-Type": "application/json", "token": app.request.headers.get("token")},
+                    )
+                    print("===========================")
+                    print("     uri: ", uri)
+                    print("     data: ", argDict)
+                    print("     response: ", response.text)
+                    print("===========================")
+                    resp = json.loads(response.text)
+                except Exception:
+                    raise Exception("响应无效")
+                if resp["errcode"] != 0:
+                    raise Exception(resp["errmsg"])
+                data = resp["data"]
+                return data
+
+        return wrapper
+
+    return inner

jit_utils/exceptions.py

@@ -0,0 +1,113 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2025/1/13 15:54
+
+@author: 'wuhao'
+
+@desc:
+"""
+import os
+import traceback
+
+from jit.commons.utils.logger import log
+from jit.errcode import ElementErrCode
+
+
+class BaseElementException(object):
+    PREFIX = "exc"
+
+    def __init__(self, fullName, title):
+        self.fullName = fullName
+        self.title = title
+
+    def getTrace(self, exc):
+        trace = traceback.extract_tb(exc.__traceback__)[-1]
+        filename, lineno, func, text = trace
+        filename = filename.replace(os.environ["rootPath"], "").replace(os.sep, ".")
+        return filename, lineno, func, text
+
+    # def other(self,exc):
+    #     """
+    #     遇到未定义的异常类型处理时调用
+    #     :param exc:
+    #     :return:
+    #     """
+
+    def handleException(self, exc):
+        exceptionName = type(exc).__name__
+        log.exception(exc)
+        handler = getattr(self, self.PREFIX + exceptionName, None)
+        if handler:
+            code = handler(exc)
+            return code
+        # 遇到使用者为定义的异常类型处理时调用
+        elif hasattr(self, "other"):
+            code = self.other(exc)
+            return code
+        # 没定义任何处理
+        else:
+            return None
+
+    def excAttributeError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "访问了{objName}对象不存在的属性{attrName}，在文件{filename}第{lineno}行,异常代码:{text}".format(
+            objName=exc.obj, attrName=exc.name, filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excValueError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "无效的值,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excTypeError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "不支持的类型操作,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excIndexError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "索引越界,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excKeyError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "字典没有这个key,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excNameError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "没有定义的变量,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excSyntaxError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "语法错误,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code
+
+    def excZeroDivisionError(self, exc):
+        filename, lineno, func, text = self.getTrace(exc)
+        errMsg = "除数为0,在文件{filename}第{lineno}行,异常代码:{text}".format(
+            filename=filename, lineno=lineno, text=text
+        )
+        code = ElementErrCode.ELEMENT_ERROR.formatReason(fullName=self.fullName, title=self.title, errMsg=errMsg)
+        return code

jit_utils/forwarder.py

@@ -0,0 +1,113 @@
+# -*-coding:utf-8-*-
+"""
+Created on 2024/12/11
+
+@author: 臧韬
+
+@desc: 默认描述
+"""
+
+import inspect
+import types
+
+
+class MethodForwarder(object):
+    """
+    cls方法转换器，可以将这个函数的所有方法都转换成目标函数，可以在不修改原始类的任何代码情况进行装饰。
+    使用方法:
+    def myfunc(args, kwargs, extends):
+        # 目标函数
+        return 2
+
+    class MyClass(object):
+        def func(self):
+            return 1
+
+    @ClsForward(myFunc)
+    class ForwardClass(MyClass):
+        pass
+
+    >> MyClass().func()
+    1
+
+    >> ForwardClass().func()
+    2
+
+    特点：
+    1. 目标函数中如果返回了 ClsForward.DoNotForward，则会执行原来的函数或者方法
+    2. 目标函数的入参必须是 args, kwargs, extend
+       args, kwargs 是调用这个函数的参数
+       extend是一个字典，包含3个参数
+        cls -> 类对象
+        self -> 如果是通过实例化的对象调用的函数或方法，这里会传入实例对象
+        func -> 执行的函数对象，如果是类方法，则返回的绑定到这个类的method对象。如果是成员方法和静态方法，则传入的是function对象。
+    3. 可以在装饰器的入参中指定excludeFunc，函数名满足这个函数则不会转发
+    参考:
+    def excludeFunc(name):
+        return name == "view" and name.startswith("_")
+
+    @ClsForward(myFunc, excludeFunc=excludeFunc)
+    class ForwardClass(MyClass):
+        pass
+
+    这样这个类在遇到view函数和开头为下划线的函数，则不会转换。
+    excludeFunc是选传的，默认情况下忽略下划线开头的函数。
+    """
+
+    DoNotForward = object()
+
+    def __init__(self, targetFunc, excludeFunc=None):
+        self.targetFunc = targetFunc
+        self.clss = None
+        self.excludeFunc = excludeFunc or self.defaultExcludeFunc
+
+    def __call__(self, clss):
+        self.clss = clss
+
+        for name in dir(clss):
+            if callable(self.excludeFunc):
+                if self.excludeFunc(name):
+                    continue
+            func = getattr(clss, name)
+            if inspect.ismethod(func):
+                setattr(clss, name, classmethod(self.classForward(func, self.targetFunc)))
+            if inspect.isfunction(func):
+                setattr(clss, name, self.classForward(func, self.targetFunc))
+        return clss
+
+    def classForward(self, func, targetFunc):
+
+        def wrapper(*args, **kwargs):
+            # 如果是实例调用方法，args第一个会传入对象
+            if args and (isinstance(args[0], self.clss) or issubclass(args[0], self.clss)):
+                sf, *rArgs = args
+                rArgs = tuple(rArgs)
+            else:
+                sf = None
+                rArgs = args
+
+            extend = {
+                "clss": self.clss,
+                "self": sf,
+                "func": func,
+            }
+            result = targetFunc(rArgs, kwargs, extend)
+            if result is self.DoNotForward:
+                if sf:
+                    if inspect.isfunction(func):
+                        # 实例方法
+                        return types.MethodType(func, sf)(*rArgs, **kwargs)
+                    else:
+                        # 类方法
+                        return types.MethodType(func.__func__, sf)(*rArgs, **kwargs)
+                else:
+                    # 静态方法
+                    return func(*rArgs, **kwargs)
+
+            return result
+
+        return wrapper
+
+    @staticmethod
+    def defaultExcludeFunc(name):
+        return name.startswith("_")