PyPI - deepfos - Versions diffs - 1.1.60__py3-none-any.whl - Mend

deepfos 1.1.60__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (175) hide show

deepfos/__init__.py +6 -0
deepfos/_version.py +21 -0
deepfos/algo/__init__.py +0 -0
deepfos/algo/graph.py +171 -0
deepfos/algo/segtree.py +31 -0
deepfos/api/V1_1/__init__.py +0 -0
deepfos/api/V1_1/business_model.py +119 -0
deepfos/api/V1_1/dimension.py +599 -0
deepfos/api/V1_1/models/__init__.py +0 -0
deepfos/api/V1_1/models/business_model.py +1033 -0
deepfos/api/V1_1/models/dimension.py +2768 -0
deepfos/api/V1_2/__init__.py +0 -0
deepfos/api/V1_2/dimension.py +285 -0
deepfos/api/V1_2/models/__init__.py +0 -0
deepfos/api/V1_2/models/dimension.py +2923 -0
deepfos/api/__init__.py +0 -0
deepfos/api/account.py +167 -0
deepfos/api/accounting_engines.py +147 -0
deepfos/api/app.py +626 -0
deepfos/api/approval_process.py +198 -0
deepfos/api/base.py +983 -0
deepfos/api/business_model.py +160 -0
deepfos/api/consolidation.py +129 -0
deepfos/api/consolidation_process.py +106 -0
deepfos/api/datatable.py +341 -0
deepfos/api/deep_pipeline.py +61 -0
deepfos/api/deepconnector.py +36 -0
deepfos/api/deepfos_task.py +92 -0
deepfos/api/deepmodel.py +188 -0
deepfos/api/dimension.py +486 -0
deepfos/api/financial_model.py +319 -0
deepfos/api/journal_model.py +119 -0
deepfos/api/journal_template.py +132 -0
deepfos/api/memory_financial_model.py +98 -0
deepfos/api/models/__init__.py +3 -0
deepfos/api/models/account.py +483 -0
deepfos/api/models/accounting_engines.py +756 -0
deepfos/api/models/app.py +1338 -0
deepfos/api/models/approval_process.py +1043 -0
deepfos/api/models/base.py +234 -0
deepfos/api/models/business_model.py +805 -0
deepfos/api/models/consolidation.py +711 -0
deepfos/api/models/consolidation_process.py +248 -0
deepfos/api/models/datatable_mysql.py +427 -0
deepfos/api/models/deep_pipeline.py +55 -0
deepfos/api/models/deepconnector.py +28 -0
deepfos/api/models/deepfos_task.py +386 -0
deepfos/api/models/deepmodel.py +308 -0
deepfos/api/models/dimension.py +1576 -0
deepfos/api/models/financial_model.py +1796 -0
deepfos/api/models/journal_model.py +341 -0
deepfos/api/models/journal_template.py +854 -0
deepfos/api/models/memory_financial_model.py +478 -0
deepfos/api/models/platform.py +178 -0
deepfos/api/models/python.py +221 -0
deepfos/api/models/reconciliation_engine.py +411 -0
deepfos/api/models/reconciliation_report.py +161 -0
deepfos/api/models/role_strategy.py +884 -0
deepfos/api/models/smartlist.py +237 -0
deepfos/api/models/space.py +1137 -0
deepfos/api/models/system.py +1065 -0
deepfos/api/models/variable.py +463 -0
deepfos/api/models/workflow.py +946 -0
deepfos/api/platform.py +199 -0
deepfos/api/python.py +90 -0
deepfos/api/reconciliation_engine.py +181 -0
deepfos/api/reconciliation_report.py +64 -0
deepfos/api/role_strategy.py +234 -0
deepfos/api/smartlist.py +69 -0
deepfos/api/space.py +582 -0
deepfos/api/system.py +372 -0
deepfos/api/variable.py +154 -0
deepfos/api/workflow.py +264 -0
deepfos/boost/__init__.py +6 -0
deepfos/boost/py_jstream.py +89 -0
deepfos/boost/py_pandas.py +20 -0
deepfos/cache.py +121 -0
deepfos/config.py +6 -0
deepfos/core/__init__.py +27 -0
deepfos/core/cube/__init__.py +10 -0
deepfos/core/cube/_base.py +462 -0
deepfos/core/cube/constants.py +21 -0
deepfos/core/cube/cube.py +408 -0
deepfos/core/cube/formula.py +707 -0
deepfos/core/cube/syscube.py +532 -0
deepfos/core/cube/typing.py +7 -0
deepfos/core/cube/utils.py +238 -0
deepfos/core/dimension/__init__.py +11 -0
deepfos/core/dimension/_base.py +506 -0
deepfos/core/dimension/dimcreator.py +184 -0
deepfos/core/dimension/dimension.py +472 -0
deepfos/core/dimension/dimexpr.py +271 -0
deepfos/core/dimension/dimmember.py +155 -0
deepfos/core/dimension/eledimension.py +22 -0
deepfos/core/dimension/filters.py +99 -0
deepfos/core/dimension/sysdimension.py +168 -0
deepfos/core/logictable/__init__.py +5 -0
deepfos/core/logictable/_cache.py +141 -0
deepfos/core/logictable/_operator.py +663 -0
deepfos/core/logictable/nodemixin.py +673 -0
deepfos/core/logictable/sqlcondition.py +609 -0
deepfos/core/logictable/tablemodel.py +497 -0
deepfos/db/__init__.py +36 -0
deepfos/db/cipher.py +660 -0
deepfos/db/clickhouse.py +191 -0
deepfos/db/connector.py +195 -0
deepfos/db/daclickhouse.py +171 -0
deepfos/db/dameng.py +101 -0
deepfos/db/damysql.py +189 -0
deepfos/db/dbkits.py +358 -0
deepfos/db/deepengine.py +99 -0
deepfos/db/deepmodel.py +82 -0
deepfos/db/deepmodel_kingbase.py +83 -0
deepfos/db/edb.py +214 -0
deepfos/db/gauss.py +83 -0
deepfos/db/kingbase.py +83 -0
deepfos/db/mysql.py +184 -0
deepfos/db/oracle.py +131 -0
deepfos/db/postgresql.py +192 -0
deepfos/db/sqlserver.py +99 -0
deepfos/db/utils.py +135 -0
deepfos/element/__init__.py +89 -0
deepfos/element/accounting.py +348 -0
deepfos/element/apvlprocess.py +215 -0
deepfos/element/base.py +398 -0
deepfos/element/bizmodel.py +1269 -0
deepfos/element/datatable.py +2467 -0
deepfos/element/deep_pipeline.py +186 -0
deepfos/element/deepconnector.py +59 -0
deepfos/element/deepmodel.py +1806 -0
deepfos/element/dimension.py +1254 -0
deepfos/element/fact_table.py +427 -0
deepfos/element/finmodel.py +1485 -0
deepfos/element/journal.py +840 -0
deepfos/element/journal_template.py +943 -0
deepfos/element/pyscript.py +412 -0
deepfos/element/reconciliation.py +553 -0
deepfos/element/rolestrategy.py +243 -0
deepfos/element/smartlist.py +457 -0
deepfos/element/variable.py +756 -0
deepfos/element/workflow.py +560 -0
deepfos/exceptions/__init__.py +239 -0
deepfos/exceptions/hook.py +86 -0
deepfos/lazy.py +104 -0
deepfos/lazy_import.py +84 -0
deepfos/lib/__init__.py +0 -0
deepfos/lib/_javaobj.py +366 -0
deepfos/lib/asynchronous.py +879 -0
deepfos/lib/concurrency.py +107 -0
deepfos/lib/constant.py +39 -0
deepfos/lib/decorator.py +310 -0
deepfos/lib/deepchart.py +778 -0
deepfos/lib/deepux.py +477 -0
deepfos/lib/discovery.py +273 -0
deepfos/lib/edb_lexer.py +789 -0
deepfos/lib/eureka.py +156 -0
deepfos/lib/filterparser.py +751 -0
deepfos/lib/httpcli.py +106 -0
deepfos/lib/jsonstreamer.py +80 -0
deepfos/lib/msg.py +394 -0
deepfos/lib/nacos.py +225 -0
deepfos/lib/patch.py +92 -0
deepfos/lib/redis.py +241 -0
deepfos/lib/serutils.py +181 -0
deepfos/lib/stopwatch.py +99 -0
deepfos/lib/subtask.py +572 -0
deepfos/lib/sysutils.py +703 -0
deepfos/lib/utils.py +1003 -0
deepfos/local.py +160 -0
deepfos/options.py +670 -0
deepfos/translation.py +237 -0
deepfos-1.1.60.dist-info/METADATA +33 -0
deepfos-1.1.60.dist-info/RECORD +175 -0
deepfos-1.1.60.dist-info/WHEEL +5 -0
deepfos-1.1.60.dist-info/top_level.txt +1 -0

deepfos/core/dimension/dimexpr.py ADDED Viewed

@@ -0,0 +1,271 @@
+import re
+from deepfos.core.logictable.nodemixin import NodeMixin, TreeRenderer
+from deepfos.lib.decorator import cached_property
+_RE_ESCAPE_QUOTE = re.compile("^'(?P<body>.*)'")
+_RE_ESCAPE_DQUOTE = re.compile('^"(?P<body>.*)"')
+class ASTNode(NodeMixin):
+    def __init__(self, value: str):
+        self.value = value
+        self.is_quoted = False
+    def __str__(self):
+        return self.value
+    @cached_property
+    def eval(self):
+        """解析维度表达式，如果为数字，直接返回，否则提取维度操作返回"""
+        val = self.value
+        if val.isdigit():
+            return int(val)
+        for patt in (_RE_ESCAPE_QUOTE, _RE_ESCAPE_DQUOTE):
+            rslt = patt.match(val)
+            if rslt is not None:
+                self.is_quoted = True
+                return rslt.group('body')
+        return self.value
+class ASTOpBase(NodeMixin):
+    """维度表达式语法树中的维度操作节点"""
+    def __init__(self, dim_obj, op_name):
+        """
+        Args:
+            dim_obj(Dimension): 维度表达式操作的维度树
+            op_name: 维度操作名
+        """
+        self._op_name = op_name
+        self._dim_obj = dim_obj
+    def solve(self):
+        """执行该节点的维度操作"""
+        args = self.collect_args()
+        return self.calc(args)
+    def calc(self, args):
+        raise NotImplementedError()
+    def eval(self, node: ASTNode):
+        return node.eval
+    def collect_args(self):
+        """收集维度操作所需的参数"""
+        args = []
+        for child in self.children:
+            if isinstance(child, ASTNode):
+                args.append(self.eval(child))
+            elif isinstance(child, ASTOpBase):
+                args.append(child.solve())
+            else:
+                raise TypeError(f"Expect type {ASTOpBase} or {ASTNode}, got {type(child)}")
+        return args
+    def _get_member(self, mbr):
+        """获取语法树中指定节点"""
+        if isinstance(mbr, str):
+            return self._dim_obj[mbr]
+        if isinstance(mbr, int):
+            return self._dim_obj[str(mbr)]
+        return mbr
+    def __str__(self):
+        """直接打印当前维度操作节点的操作名"""
+        return self._op_name
+class ASTOpHierachy(ASTOpBase):
+    """
+    Operator class for getting dimension hierachy
+    维度表达式语法树中的层级操作节点
+    """
+    def calc(self, args):
+        """
+        计算当前节点的层级结果
+        Args:
+            args: 层级操作所需的参数
+        Returns:
+            返回当前节点的层级结果列表
+        """
+        hierachy = self._op_name
+        member, reverse, *remain = args
+        order = -1 if reverse != 0 else 1
+        dim_container = self._dim_obj[str(member)]
+        if hierachy in {'Level', 'ILevel'}:
+            start, stop = remain
+            return getattr(dim_container, hierachy)[start:stop:order]
+        else:
+            return getattr(dim_container, hierachy)[::order]
+class ASTOpAttr(ASTOpBase):
+    def eval(self, node: ASTNode):
+        val = node.eval
+        if node.is_quoted:
+            return {'N': False, 'Y': True}.get(val, val)
+        else:
+            return val
+    def calc(self, args):
+        """构建 ``filter`` 过滤字典"""
+        key, val = args
+        return {key: val}
+class ASTOpFilter(ASTOpBase):
+    """过滤操作语法树节点"""
+    filter_map = {
+        "OrFilter": "or",
+        "AndFilter": "and",
+        "NorFilter": "nor",
+        "NAndFilter": "nand",
+    }
+    def calc(self, args):
+        _filter = self.filter_map[self._op_name]
+        dim_container, *conditions = args
+        dim_container = self._get_member(dim_container)
+        all_cond = {}
+        for cond in conditions:
+            all_cond.update(cond)
+        return dim_container.where(_filter, **all_cond)
+class ASTOpRemove(ASTOpBase):
+    """删除操作语法树节点"""
+    def calc(self, args):
+        dim_container, *remain = args
+        dim_container = self._get_member(dim_container)
+        to_remove = []
+        for item in remain:
+            to_remove.append(self._get_member(item))
+        return dim_container.remove(*to_remove)
+class ASTOpRoot(ASTOpBase):
+    """语法树根节点，将维度表达式最终结果收集，并存储到 ``Dimension`` 中的查询集"""
+    def __init__(self, dim_obj):
+        super().__init__(dim_obj, 'Root')
+        self._dim_obj = dim_obj
+    def calc(self, args):
+        to_select = (self._get_member(mbr) for mbr in args)
+        return self._dim_obj.select(*to_select)
+    def __str__(self):
+        return 'DummyRoot'
+class ASTOpFactory:
+    """语法树维度操作节点工程，可以根据 ``cls_map`` 创建不同的维度操作节点"""
+    cls_map = {
+        'Remove': ASTOpRemove,
+        "OrFilter": ASTOpFilter,
+        "AndFilter": ASTOpFilter,
+        "NorFilter": ASTOpFilter,
+        "NAndFilter": ASTOpFilter,
+        "Attr": ASTOpAttr,
+        "Base": ASTOpHierachy,
+        "IBase": ASTOpHierachy,
+        "Children": ASTOpHierachy,
+        "IChildren": ASTOpHierachy,
+        "Descendant": ASTOpHierachy,
+        "IDescendant": ASTOpHierachy,
+        "Level": ASTOpHierachy,
+        "ILevel": ASTOpHierachy,
+    }
+    def __new__(cls, dim, value):
+        target_cls = cls.cls_map.get(value)
+        if target_cls is None:
+            raise ValueError(f"Unknow Expression: {value}")
+        return target_cls(dim, value)
+class DimExprAnalysor:
+    """基于语法树的维度表达式分析器"""
+    def __init__(self, dimension, dim_expr):
+        self.dim = dimension
+        self.dummy_root = ASTOpRoot(dimension)
+        for expr in dim_expr.split(";"):
+            self._gen_ast(expr)
+    def _gen_ast(self, expr):
+        """创建语法树"""
+        root_stack = [self.dummy_root]
+        dim = self.dim
+        end_bracket = False
+        tmp_string = []
+        last_char = ')'
+        for char in expr:
+            if char == '(':
+                node = ASTOpFactory(dim, ''.join(tmp_string))
+                tmp_string.clear()
+                node.set_parent(root_stack[-1])
+                root_stack.append(node)
+            elif char == ',':
+                if not end_bracket:
+                    node = ASTNode(''.join(tmp_string))
+                    tmp_string.clear()
+                    node.set_parent(root_stack[-1])
+                else:
+                    end_bracket = False
+            elif char == ')':
+                if not end_bracket:
+                    node = ASTNode(''.join(tmp_string))
+                    tmp_string.clear()
+                    root = root_stack.pop(-1)
+                    node.set_parent(root)
+                    end_bracket = True
+                else:
+                    root_stack.pop(-1)
+            else:
+                if char == ' ' and last_char in {')', ','}:
+                    char = last_char  # 去除连续空格
+                else:
+                    tmp_string.append(char)
+            last_char = char
+        if tmp_string:
+            node = ASTNode(''.join(tmp_string))
+            node.set_parent(root_stack[-1])
+    def show_ast(self):
+        """
+        打印语法树
+        Example:
+            .. code-block:: python
+                # dim 是加载维度表达式的维度树
+                dim_expr = DimExprAnalysor(dim, 'Base(node, 0)')
+                dim_expr.show_ast()
+                # 执行上述代码会打印如下所示的语法树：
+                '''
+                DummyRoot
+                └── Base
+                    ├── node
+                    └── 0
+                '''
+        """
+        print(TreeRenderer().render(self.dummy_root))
+        return self
+    def solve(self):
+        """计算维度表达式结果，返回已加载执行维度表达式的维度，结果存储在 `selected` 集合中"""
+        return self.dummy_root.solve()

deepfos/core/dimension/dimmember.py ADDED Viewed

@@ -0,0 +1,155 @@
+from deepfos.core.logictable.nodemixin import ShareableNodeMixin
+from ._base import MemberContainer, MemberBase, pack_filter, flatten
+class GeneralMemberProxy(MemberContainer):
+    def __init__(self, *anchor_mbrs, hierarchy=None, node_attr=None):
+        super().__init__(*anchor_mbrs, hierarchy=hierarchy)
+        self.node_attr = node_attr
+    def _get_all_member(self):
+        super()._get_all_member()
+        return flatten(getattr(mbr, self.node_attr) for mbr in self.anchor_mbrs)
+class LevelMemberProxy(GeneralMemberProxy):
+    @property
+    def members(self):
+        include = self.node_attr.startswith('i')
+        levels = flatten(list(mbr.iter_level(self.start, self.stop, include)) for mbr in self.anchor_mbrs)
+        return self.apply_filter(levels)
+    def __getitem__(self, item):
+        super().__getitem__(item)
+        start, stop = item.start, item.stop
+        if start is None:
+            raise ValueError("Start level is not specified.")
+        if stop is None:
+            raise ValueError("Stop level is not specified.")
+        if stop <= start:
+            raise ValueError("Stop level should be greater than start.")
+        self.start, self.stop = start, stop
+        return self
+    def __str__(self):
+        order = 1 if self._reversed else 0
+        if self.start is None or self.stop is None:
+            raise RuntimeError(
+                "start|stop level is not specified. "
+                "Use slice [] syntax to indicated level detail.")
+        raw_expr = ';'.join(
+            f"{self.hierarchy}({anchor},{order},{self.start},{self.stop})"
+            for anchor in self.anchor_mbrs)
+        return pack_filter(raw_expr, self._filters)
+class AsMbrProxy:
+    def __init__(self, data_mapping, proxy_cls=GeneralMemberProxy):
+        self._dmap = data_mapping
+        self.proxy_cls = proxy_cls
+    def __get__(self, instance, owner=None):
+        proxy = self.proxy_cls(instance, hierarchy=self.name, node_attr=self._dmap)
+        return proxy
+    def __set_name__(self, owner, name):
+        self.name = name
+class DimMember(MemberBase, ShareableNodeMixin):
+    def __init__(self, name):
+        super(DimMember, self).__init__(name)
+        self.extra_attrs = ()
+    #: 寻找以当前节点为根的维度树的叶子节点。
+    Base = AsMbrProxy("base")
+    #: 寻找以当前节点为根的维度树的叶子节点，包含自身。
+    IBase = AsMbrProxy("ibase")
+    #: 寻找当前节点的直接孩子节点。
+    Children = AsMbrProxy("children")
+    #: 寻找当前节点的直接孩子节点， 包含自身。
+    IChildren = AsMbrProxy("ichildren")
+    #: 寻找当前节点的后继节点。
+    Descendant = AsMbrProxy("descendant")
+    #: 寻找当前节点的后继节点，包含自身。
+    IDescendant = AsMbrProxy("idescendant")
+    #: level节点。
+    Level = AsMbrProxy("level", LevelMemberProxy)
+    #: level节点，包含自身。
+    ILevel = AsMbrProxy("ilevel", LevelMemberProxy)
+    @property
+    def data(self):
+        """返回当前维度成员的成员名， ``list`` 类型。"""
+        return [self.name]
+    def to_dict(self, *attrs, name, parent_name, show_all=False, exclude=None):
+        """
+        将当前维度成员及其指定属性存储为字典。
+        Args:
+            *attrs(dict): 字典需要包含的维度成员指定属性
+            name(str): 维度成员名
+            parent_name(str): 维度成员的父节点名
+            show_all(bool): 显示成员的所有属性
+            exclude: 需要排除（不输出）的属性
+        Returns:
+            包含当前维度成员指定信息的字典
+        """
+        if show_all:
+            attrs = self.extra_attrs
+        if isinstance(exclude, str):
+            exclude = {exclude}
+        else:
+            exclude = exclude or set()
+        rtn = {attr: getattr(self, attr) for attr in attrs if attr not in exclude}
+        rtn[name] = self.name
+        parent = self.parent
+        rtn[parent_name] = None if not parent else [p.name for p in parent]
+        return rtn
+    def where(self, method, **kwargs):
+        """
+        判断当前维度成员的属性按照 ``method`` 是否符合指定属性。
+        Args:
+            method(str): 判断方法，包含 ``and` ， ``nand`` ， ``or`` ， ``nor``
+            **kwargs: 要求的属性
+        Returns:
+            成员对象容器
+        Warnings:
+            返回值是成员对象容器，需要调用容器的 ``members`` 或 ``data`` 才能执行操作。
+            此函数一般用于和 ``Dimension`` 的 ``select`` 搭配使用，不推荐单独使用。
+        """
+        return MemberContainer(self).where(method, **kwargs)
+    def remove(self, *to_remove):
+        """
+        移除当前成员对象
+        Args:
+            *to_remove(DimMember): 需要移除的成员对象
+        Returns:
+            成员对象容器
+        Warnings:
+            返回值是成员对象容器，需要调用容器的 ``members`` 才能执行操作。
+            如果当前成员对象存在于 ``*to_remove`` 中，则移除当前成员对象，否则，直接返回。
+            此函数一般用于和 ``Dimension`` 的 ``select`` 搭配使用，不推荐单独使用。
+        """
+        return MemberContainer(self).remove(*to_remove)

deepfos/core/dimension/eledimension.py ADDED Viewed

@@ -0,0 +1,22 @@
+from ._base import DimensionBase, MemberBase
+from deepfos.element.dimension import Dimension as EleDimension
+class ElementDimension(DimensionBase):
+    def __init__(self, dimension: EleDimension):
+        self.ele = dimension
+        super(ElementDimension, self).__init__(dimension.element_name)
+    def load_expr(self, expr) -> 'ElementDimension':
+        self.selected = selected = []
+        for record in self.ele.query(
+                expr, fields=['name', 'aggweight'],
+                as_model=False
+        ):
+            mbr = MemberBase(record['name'])
+            mbr.weight = record['aggweight']
+            selected.append(mbr)
+        return self
+    def __getitem__(self, item):
+        return item

deepfos/core/dimension/filters.py ADDED Viewed

@@ -0,0 +1,99 @@
+__all__ = ['AndFilter', 'NAndFilter', 'OrFilter', 'NorFilter', 'RemoveFilter', 'BaseFilter']
+import functools
+_NOTSET = object()
+class BaseFilter:
+    def __init__(self, attr_kv_pairs, objs=None):
+        """
+        Args:
+            attr_kv_pairs(dict): 属性键值对
+            objs: 被过滤的对象
+        """
+        self.objs = objs
+        self.attr_kv_pairs = attr_kv_pairs
+    def iter_single(self, obj):
+        for attr, val in self.attr_kv_pairs.items():
+            actual = getattr(obj, attr, _NOTSET)
+            if actual is _NOTSET:
+                yield False
+            else:
+                yield val == actual
+    def filter_strategy(self, obj):
+        """过滤策略"""
+        raise NotImplementedError()
+    def apply(self):
+        """执行过滤策略"""
+        return self.apply_to(self.objs)
+    def apply_to(self, objs):
+        """返回符合过滤策略的对象列表"""
+        return [obj for obj in objs if self.filter_strategy(obj)]
+    def __str__(self):
+        return self.__class__.__name__
+class AndFilter(BaseFilter):
+    """筛选符合全部属性要求的节点"""
+    def filter_strategy(self, obj):
+        return all(self.iter_single(obj))
+class NAndFilter(AndFilter):
+    """筛选除了符合全部属性要求节点的节点"""
+    def filter_strategy(self, obj):
+        return not super().filter_strategy(obj)
+class OrFilter(BaseFilter):
+    """筛选符合任意一项属性要求的节点"""
+    def filter_strategy(self, obj):
+        return any(self.iter_single(obj))
+class NorFilter(OrFilter):
+    """筛选不符合全部属性要求的节点"""
+    def filter_strategy(self, obj):
+        return not super().filter_strategy(obj)
+class RemoveFilter:
+    def __init__(self, to_remove, mbr_getter=None):
+        """
+        Args:
+            to_remove(list): 列表元素为 ``DimMember`` 类型，需要移除的节点
+            mbr_getter:
+        """
+        self.to_remove = to_remove
+        self.getter = mbr_getter or (lambda x: x)
+    def apply_to(self, total):
+        """
+        Args:
+            total(list):  ``DimMember`` 对象列表，从中移除 ``to_remove`` 中的对象
+        Returns:
+            返回 ``DimMember`` 对象列表
+        Tips:
+            如果需要被移除的对象不存在于 ``total`` 中，则不做任何事
+        """
+        if not self.to_remove:
+            return total
+        to_remove = functools.reduce(
+            lambda x, y: x | y,
+            (set(self.getter(obj)) for obj in self.to_remove),
+            set()
+        )
+        return [obj for obj in total if obj not in to_remove]
+    def __str__(self):
+        return 'Remove'