deepfos 1.1.60__py3-none-any.whl

deepfos/exceptions/__init__.py

@@ -0,0 +1,239 @@
+from .hook import eliminate_from_traceback
+
+
+class DeepfosBaseException(Exception):
+    """deepfos自定义异常基类"""
+
+
+# -----------------------------------------------------------------------------
+# Option Error
+class BaseOptionError(DeepfosBaseException):
+    """配置项异常基类"""
+
+
+class OptionNotSetError(BaseOptionError):
+    """配置项未设置"""
+
+
+class OptionTypeError(BaseOptionError):
+    """配置项类型错误"""
+
+
+class OptionValueError(BaseOptionError):
+    """配置项值错误"""
+
+
+# -----------------------------------------------------------------------------
+# API Error
+class APIError(DeepfosBaseException, OSError):
+    """API相关异常"""
+
+
+class APIRequestError(APIError):
+    """调用API时请求异常"""
+
+
+class APIResponseError(APIError):
+    """调用API返回异常"""
+    def __init__(self, msg, code=None):
+        super().__init__(msg)
+        self.code = code
+
+
+# -----------------------------------------------------------------------------
+# Element Error
+
+class ElementError(DeepfosBaseException):
+    """元素相关异常"""
+
+
+class ElementTypeMissingError(ElementError):
+    """无法获取元素类型"""
+
+
+class ElementNotFoundError(ElementError):
+    """元素不存在"""
+
+
+class ElementAmbiguousError(ElementError):
+    """无法锁定唯一元素"""
+
+
+class ElementVersionIncompatibleError(ElementError):
+    """元素版本不兼容"""
+
+
+class DimensionSaveError(ElementError):
+    """无法保存维度"""
+
+
+class MemberNotFoundError(ElementError):
+    """维度成员不存在"""
+
+
+class VariableUpdateError(ElementError):
+    """无法更新变量"""
+
+
+class VariableCreateError(ElementError):
+    """无法新建变量"""
+
+
+# -----------------------------------------------------------------------------
+# RedisLock Error
+
+class LockAcquireFailed(DeepfosBaseException):
+    """无法获取Redis锁"""
+
+
+class BadFutureError(DeepfosBaseException):
+    """获取future property返回值过程出现错误"""
+    def __init__(self, msg, obj):
+        super().__init__(msg)
+        self.obj = obj
+
+
+# -----------------------------------------------------------------------------
+# Pyscript Error
+class PyTaskError(DeepfosBaseException):
+    """执行脚本报错基类"""
+    base_msg = ''
+
+    def __init__(self, *reasons):
+        self.reasons = reasons
+
+    def __str__(self):
+        if self.base_msg and self.reasons:
+            return self.base_msg.format(*self.reasons)
+        return self.__class__.__doc__
+
+
+class ResultTimeOutError(PyTaskError):
+    """等待python执行结果超时"""
+
+
+class PyTaskInvalidError(PyTaskError):
+    """无效的python任务ID"""
+
+
+class PyTaskRevokedError(PyTaskError):
+    """python脚本被中断执行"""
+
+
+class PyTaskRunTimeError(PyTaskError):
+    """执行脚本出错"""
+    base_msg = 'python脚本执行时发生错误，错误信息:\n{}'
+
+
+class PyTaskConcurrencyExceed(PyTaskError):
+    """任务并发数过高"""
+    base_msg = '当前节点[{}]尝试获取结果的python任务并发数[{}]过高，请稍后尝试获取结果'
+
+
+class PyTaskTimeLimitExceed(PyTaskError):
+    """python脚本运行时间超过最大限制"""
+
+
+# -----------------------------------------------------------------------------
+# FinancialCube Error
+class MDXExecuteTimeout(DeepfosBaseException):
+    """执行MDX任务超时"""
+
+
+class MDXExecuteFail(DeepfosBaseException):
+    """执行MDX任务失败"""
+
+
+# -----------------------------------------------------------------------------
+# DeepModel Error
+class DeepModelError(DeepfosBaseException):
+    """DeepModel相关报错基类"""
+
+
+class ObjectNotExist(DeepModelError):
+    """DeepModel对象不存在"""
+
+
+class RequiredFieldUnfilled(DeepModelError):
+    """缺少必填字段"""
+
+
+class ExternalObjectReadOnly(DeepModelError):
+    """外部对象只可读"""
+
+
+class RelationRequired(DeepModelError):
+    """multi link字段缺少relation信息"""
+
+
+class SingleLinkInRelation(DeepModelError):
+    """single link字段出现在relation中"""
+
+
+class MultiLinkTargetNotUnique(DeepModelError):
+    """relation信息source的target不唯一"""
+
+
+# -----------------------------------------------------------------------------
+# JournalModel Error
+class JournalModelError(DeepfosBaseException):
+    """JournalModel相关报错基类"""
+
+
+class JournalModelSaveError(JournalModelError, ValueError):
+    """JournalModel保存失败"""
+
+
+class JournalModelCheckError(JournalModelError):
+    """JournalModel校验失败"""
+
+
+class JournalModelPostingError(JournalModelError):
+    """JournalModel过账/取消过账失败"""
+
+
+# -----------------------------------------------------------------------------
+# MsgCenter Error
+class MsgCenterError(DeepfosBaseException):
+    """消息中心推送失败"""
+    def __init__(self, *reasons):
+        self.reasons = reasons
+
+    def __str__(self):
+        return '推送失败，报错信息：' + '\n'.join([r.errorMsg for r in self.reasons])
+
+
+# -----------------------------------------------------------------------------
+# DeepPipeline Error
+class DeepPipelineRunError(DeepfosBaseException):
+    """执行脚本报错基类"""
+    base_msg = ''
+
+    def __init__(self, *reasons):
+        self.reasons = reasons
+
+    def __str__(self):
+        if self.base_msg and self.reasons:
+            return self.base_msg.format(*self.reasons)
+        return self.__class__.__doc__
+
+
+class RunIdInvalid(DeepPipelineRunError):
+    """执行ID无效"""
+
+
+class RunTerminated(DeepPipelineRunError):
+    """数据流执行被取消"""
+
+
+class ReleaseFlowTimeout(DeepPipelineRunError):
+    """获取结果等待超时"""
+
+
+class RunFailedError(DeepPipelineRunError):
+    """数据流执行失败"""
+    base_msg = '数据流执行失败，报错信息：{}'
+
+
+class ReleaseFlowNotExists(DeepPipelineRunError):
+    """暂无启用中状态的数据流版本"""

deepfos/exceptions/hook.py

@@ -0,0 +1,86 @@
+import sys
+import inspect
+
+from collections import defaultdict
+from types import TracebackType
+from typing import Type, NamedTuple, Dict, Set, Union, Optional
+
+
+_builtin_exp_hook = sys.excepthook
+
+
+class CodeSpot(NamedTuple):
+    filename: str
+    first_lineno: int
+    last_lineno: Union[int, float]
+
+
+class CodeLocator:
+    spots: Dict[str, Set[CodeSpot]] = defaultdict(set)
+
+    @classmethod
+    def add_spot(cls, spot: CodeSpot):
+        cls.spots[spot.filename].add(spot)
+
+    @classmethod
+    def contains_tb(cls, tb: TracebackType):
+        frame = inspect.getframeinfo(tb.tb_frame)
+        if frame.filename not in cls.spots:
+            return False
+
+        return any(
+            spot.first_lineno <= frame.lineno < spot.last_lineno
+            for spot in cls.spots[frame.filename]
+        )
+
+
+def eliminate_from_traceback(obj):
+    """将对象从错误栈中移除（可作为装饰器）
+
+    Args:
+        obj:  需要排除的对象，可以是文件名，函数（方法），类
+
+    Notes:
+
+        - 由于技术原因，第一个错误栈无法移除。
+        - 出于可读性考虑，最后一个错误栈也不会移除
+
+    """
+    if isinstance(obj, str):
+        filename = obj
+        first_lineno = 0
+        last_lineno = float('inf')
+    else:
+        code, first_lineno = inspect.getsourcelines(obj)
+        last_lineno = first_lineno + len(code)
+        filename = inspect.getfile(obj)
+    CodeLocator.add_spot(CodeSpot(
+        filename=filename,
+        first_lineno=first_lineno,
+        last_lineno=last_lineno
+    ))
+    return obj
+
+
+def exception_hook(
+    exc_type: Type[BaseException], 
+    exc_value: BaseException, 
+    tb: Optional[TracebackType]
+):
+    if tb is not None:
+        contains_tb = CodeLocator.contains_tb
+        tb_last = tb
+        
+        while (tb_next := tb_last.tb_next) is not None:
+            if (
+                contains_tb(tb_next)
+                and (next_tb := tb_next.tb_next) is not None
+            ):
+                tb_last.tb_next = next_tb
+            else:
+                tb_last = tb_next
+
+    return _builtin_exp_hook(exc_type, exc_value, tb)
+
+
+sys.excepthook = exception_hook

deepfos/lazy.py

@@ -0,0 +1,104 @@
+import sys
+from importlib import import_module
+from types import ModuleType
+from typing import Dict, Sequence, Any
+
+from deepfos.lib.constant import UNSET
+from deepfos.local import Proxy
+
+
+class LazyModule(ModuleType):
+
+    def __init__(self, module_name, parent_module_globals):
+        self._module_name = module_name
+        self._parent_module_globals = parent_module_globals
+
+        super(LazyModule, self).__init__(module_name)
+
+    def _load(self):
+        """Load the module and insert it into the parent's globals."""
+        # Import the target module and insert it into the parent's namespace
+        module = import_module(self.__name__)
+        self._parent_module_globals[self._module_name] = module
+
+        # Update this object's dict so that if someone keeps a reference to the
+        #   LazyLoader, lookups are efficient
+        #   (__getattr__ is only called on lookups that fail).
+        self.__dict__.update(module.__dict__)
+
+        return module
+
+    def __getattr__(self, attr):
+        module = self._load()
+        return getattr(module, attr)
+
+    def __dir__(self):
+        module = self._load()
+        return dir(module)
+
+
+class LazyCallable(Proxy):
+    def __init__(self, module, local_name):
+        object.__setattr__(self, '_LazyCallable__module', module)
+        object.__setattr__(self, '_LazyCallable__local_name', local_name)
+        object.__setattr__(self, '_LazyCallable__callable', UNSET)
+
+    __module__ = Proxy.__module__
+
+    def _get_current_object(self):
+        if self.__callable is not UNSET:
+            return self.__callable
+
+        try:
+            mod = sys.modules[self.__module]
+        except KeyError:
+            mod = lazy_module(self.__module)
+
+        object.__setattr__(
+            self, '_LazyCallable__callable', 
+            getattr(mod, self.__local_name)
+        )
+        return self.__callable
+
+    def __await__(self):
+        return self._get_current_object().__await__()
+
+
+def lazy_module(modname):
+    """获得懒加载模块
+
+    Args:
+        modname: 模块名，形如aaa.bbb.ccc，将得到等效于from aaa.bbb import ccc的懒加载模块
+
+
+    """
+    return LazyModule(modname, globals())
+
+
+def lazy_callable(modname, *names):
+    """获得对应模块里的若干方法/函数的懒加载代理
+
+    Args:
+        modname : 模块名，形如aaa.bbb.ccc
+        names : 方法/函数名
+
+    """
+    return tuple(LazyCallable(modname, cname) for cname in names)
+
+
+def lazify(
+    target: Dict[str, Sequence[str]],
+    _globals: Dict[str, Any]
+):
+    """懒加载模块成员
+
+    Args:
+        target: module to module members
+        _globals: globals in caller scope
+    """
+
+    for modname, mbrs in target.items():
+        _globals.update(zip(
+            mbrs,
+            lazy_callable(modname, *mbrs)
+        ))

deepfos/lazy_import.py

@@ -0,0 +1,84 @@
+import sys
+from importlib import import_module
+from types import ModuleType
+
+from deepfos.lib.constant import UNSET
+from deepfos.local import Proxy
+
+
+class LazyModule(ModuleType):
+
+    def __init__(self, module_name, parent_module_globals):
+        self._module_name = module_name
+        self._parent_module_globals = parent_module_globals
+
+        super(LazyModule, self).__init__(module_name)
+
+    def _load(self):
+        """Load the module and insert it into the parent's globals."""
+        # Import the target module and insert it into the parent's namespace
+        module = import_module(self.__name__)
+        self._parent_module_globals[self._module_name] = module
+
+        # Update this object's dict so that if someone keeps a reference to the
+        #   LazyLoader, lookups are efficient
+        #   (__getattr__ is only called on lookups that fail).
+        self.__dict__.update(module.__dict__)
+
+        return module
+
+    def __getattr__(self, attr):
+        module = self._load()
+        return getattr(module, attr)
+
+    def __dir__(self):
+        module = self._load()
+        return dir(module)
+
+
+class LazyCallable(Proxy):
+    def __init__(self, module, local_name):
+        object.__setattr__(self, '_LazyCallable__module', module)
+        object.__setattr__(self, '_LazyCallable__local_name', local_name)
+        object.__setattr__(self, '_LazyCallable__callable', UNSET)
+
+    __module__ = Proxy.__module__
+
+    def _get_current_object(self):
+        if self.__callable is not UNSET:
+            return self.__callable
+
+        try:
+            mod = sys.modules[self.__module]
+        except KeyError:
+            mod = lazy_module(self.__module)
+
+        object.__setattr__(self, '_LazyCallable__callable', getattr(mod, self.__local_name))
+        return self.__callable
+
+    def __await__(self):
+        return self._get_current_object().__await__()
+
+
+def lazy_module(modname):
+    """获得懒加载模块
+
+    Args:
+        modname: 模块名，形如aaa.bbb.ccc，将得到等效于from aaa.bbb import ccc的懒加载模块
+
+
+    """
+    class _LazyModule(LazyModule):
+        pass
+    return _LazyModule(modname, globals())
+
+
+def lazy_callable(modname, *names):
+    """获得对应模块里的若干方法/函数的懒加载代理
+
+    Args:
+        modname : 模块名，形如aaa.bbb.ccc
+        names : 方法/函数名
+
+    """
+    return tuple(LazyCallable(modname, cname) for cname in names)