9.2合并SDK说明

test_str=EntityStr('[A].[B]')
print(test_str.pc())
# 返回[A].[B]

test_str=EntityStr('[A].[B]')
print(test_str.ch())
# 返回B

from Python.deep_consol.config import config

path_setting = {
    'DIM': {
        'Entity': '/Consolidation_App/Common/Dimension/',
        'Partner': '/Consolidation_App/Common/Dimension/',
        'EntityFilter': '/Consolidation_App/Common/Dimension/',
        'Period': '/Consolidation_App/Common/Dimension/',
    },
    'Table': {
        'EntityHierarchy': '/Consolidation_App/Entity/Entity_Hierarchy/',
        'Entity': '/Consolidation_App/Entity/Entity/',
        'Investment': '/Consolidation_App/Entity/Investment/',
        'consol_unit': '/Consolidation_App/Consol_Process_New/consol_process_new_tables_ectl/',
        'consol_unit_contribution': '/Consolidation_App/Consol_Process_New/consol_process_new_tables_ectl/'

    },
    'Cube': {'main_cube': ['Main_Cube', '/Consolidation_App/Consolidation/Main_Model/'],
             'fvadj_cube': ['FVadj_Cube', '/Consolidation_App/PPA/PPA_Model/'],
             'exrate_cube': ['ExRate_Cube', '/Consolidation_App/Rate/Rate_Model/'],
             },
    'Journal_model': {
        'name': 'Journal_Model',
        'path': '/Consolidation_App/Journal/Journal_Model/'
    }
}
# 调度顺序是否依赖投资关系
config.is_rely_investment = True
# 是否分层调度
config.is_stratified_schedule = False
# ec 结转 时 'ASSET', 'LIABILITY', 'EQUITY', 'REVENUE', 'EXPENSE' 科目的 round位数
config.ec_round_num = 2
# 是否需要按照审计线索结转
config.need_audit_carry = True
# 子代实体对应的审计线索维度成员
config.source_member = 'REPORT'
# 父级实体对应的审计线索维度成员
config.dest_member = 'CARRY'
# 审计线索对应的列名
config.audit_column = 'audittrail'
# 合并下级是否执行贡献
config.consolidate_subordinate_with_contribute = True
# 合并下级是否执行折算
config.consolidate_subordinate_with_translate = True
# SchedulerData.all_entity 是否限定在当前节点的后代范围内(可能影响deep_cube 初始化取数范围)，如果是False可能会扩大取数范围取别的架构下的数据
config.all_entity_restricted_within_descendant_member = False
# 是否使用自定义的结转ec方法
config.use_custom_data_to_ec = False
# 是否使用celery
config.use_celery = True
# 最大celery并发数
config.max_celery_concurrency = 4
# 状态是否需要向上传播
config.upward_status_transmission = True
#  使用celery进行并发调度情况下 一次合并最多跑多少个合并实体 
config.max_consolidated_entity = 32
from deepfos.element.datatable import DataTableMySQL as DataTable  # noqa
from deepfos.element.datatable import AsyncDataTableMySQL as AsyncDataTable # noqa

try:
    from deepfos.element.pyscript import redis_cli # noqa
except Exception:  # noqa
    redis_cli = None
cache_client = redis_cli
# from deepfos import OPTION
# OPTION.general.log_level = 'DEBUG'
# OPTION.api.dump_always = True

from concurrent.futures import as_completed
from typing import Dict

from deepcube.cube.cube import DeepCube
from deepfos.lib.concurrency import ThreadCtxExecutor

from Python.common.common_tools import time_log
from Python.config import path_setting
from Python.deep_consol.action_enum import ActionEnum
from Python.deep_consol.cube_info import CubeInfo
from .common.log import logger
from deepcube import Config

Config.dim_init_max_concurrency = 16
Config.data_submit_chunksize = 1000000

Config.db_direct_access = False

cube_dict: Dict[str, DeepCube] = {}
main_cube = DeepCube(element_name=path_setting['Cube']['main_cube'][0], path=path_setting['Cube']['main_cube'][1])
ex_rate_cube = DeepCube(element_name=path_setting['Cube']['exrate_cube'][0], path=path_setting['Cube']['exrate_cube'][1])

# 数据库链接信息
ck_connection_prop = None


class CubeConfig(CubeInfo):

    @time_log
    def init_cube(self, action_code: ActionEnum, con_p2: Dict, all_entity=None):
        def init_ex_cube():
            try:
                # 初始化汇率模型
                ex_rate_cube.init_data()
                cube_dict['exrate_cube'] = ex_rate_cube
            except Exception as e:
                logger.exception('初始化汇率模型失败')
                raise e

        def init_main_cube():
            try:
                # 初始化主模型
                if str(con_p2['period']) == '1':
                    last_period = '1'
                else:
                    last_period = str(int(con_p2['period']) - 1)
                last_year = str(int(con_p2['year']) - 1)
                if (action_code == ActionEnum.consolidation) or (action_code == ActionEnum.consolidation_all) or (
                        action_code == ActionEnum.consolidate_subordinate):
                    entity_member_set = self.entity_dim[all_entity]
                    # 从cube加载数据
                    source_list = [
                        (
                            self.year_dim[con_p2['year']],
                            self.period_dim[[con_p2['period'], last_period]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,
                        ),
                        (
                            self.year_dim[last_year],
                            self.period_dim[["12"]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        )

                    ]
                    self.main_cube.init_data(*source_list, partition_by=self.entity_field)

                    cube_dict['main_cube'] = self.main_cube

                elif action_code == ActionEnum.calculation:
                    # 默认为当前实体
                    entity_member_set = self.entity_dim[con_p2['entity']]
                    # 从cube加载数据
                    source_list = [
                        (
                            self.year_dim[con_p2['year']],
                            self.period_dim[[con_p2['period'], last_period]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        ),
                        (
                            self.year_dim[last_year],
                            self.period_dim[["12"]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        )

                    ]
                    self.main_cube.init_data(*source_list, partition_by=self.entity_field)
                    cube_dict['main_cube'] = self.main_cube
                elif action_code == ActionEnum.translation:
                    # 默认为当前实体
                    entity_member_set = self.entity_dim[con_p2['entity']]
                    # 从cube加载数据
                    source_list = [
                        (
                            self.year_dim[con_p2['year']],
                            self.period_dim[[con_p2['period'], last_period]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        ),
                        (
                            self.year_dim[last_year],
                            self.period_dim[["12"]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        )

                    ]
                    self.main_cube.init_data(*source_list, partition_by=self.entity_field)
                    cube_dict['main_cube'] = self.main_cube

                elif action_code == ActionEnum.contribution:

                    entity_member_set = self.entity_dim[all_entity]
                    # 如果要做在合并流程中做抵销的轧差,可能需要取兄弟节点的数据(及其后代)
                    # entity_member_set = self.entity_dim[all_entity] + self.entity_dim[con_p2['parent']].Descendant(
                    #     with_parent=True) + self.entity_dim[con_p2['parent']].Descendant()
                    # 从cube加载数据
                    source_list = [
                        (
                            self.year_dim[con_p2['year']],
                            self.period_dim[[con_p2['period'], last_period]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        ),
                        (
                            self.year_dim[last_year],
                            self.period_dim[["12"]],
                            self.scenario_dim[con_p2['scenario']],
                            self.version_dim[con_p2['version']],
                            entity_member_set,

                        )

                    ]
                    self.main_cube.init_data(*source_list, partition_by=self.entity_field)
                    cube_dict['main_cube'] = self.main_cube
                else:
                    raise ValueError('ACTION_CODE 不合法')
            except Exception as e:
                logger.exception('初始化主模型失败')
                raise e

        with ThreadCtxExecutor(max_workers=2) as executor:
            futures = [
                executor.submit(init_ex_cube),
                executor.submit(init_main_cube),
            ]
            for f in as_completed(futures):
                print(f.result())


cube_config = CubeConfig(main_cube)


def get_main_cube():
    if 'main_cube' in cube_dict:
        cube = cube_dict['main_cube']
        return cube
    else:
        raise RuntimeError('cube 尚未被初始化')


def get_ex_rate_cube():
    if 'exrate_cube' in cube_dict:
        cube = cube_dict['exrate_cube']
        return cube
    else:
        raise RuntimeError('cube 尚未被初始化')

{
    'parent': None,
    'jobId': 'consol_process_9e364a47-5f83-44b3-a587-510e0f2af3df',
    'period': '10',
    'year': '2021',
    'scenario': 'Actual',
    'consolProcessElement': {
        'elementName': 'Consol_Process',
        'elementType': 'CONSOLPROC',
        'folderId': 'DIRcca5ba18db1d',
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\',
        'serverName': 'consolidation-process-server1-0'
    },
    'consolUnitContribution': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit_contribution',
        'tableName': 'eijuqd015_t_contribution_fk09y'
    },
    'consolUnit': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit',
        'tableName': 'eijuqd015_consol_unit_8ws4a'
    },
    'unitId': '2023_1_Actual_Working_TotalEntity',
    'version': 'Working',
    'entity': 'MC',
    # 执行逻辑的枚举：包括calculation、consolidation、consolidation_all、contribution、translation
    'action': 'consolidation',
    'target_vertex': 'MC',
    # 目标实体
    'all_entity': {
      # 与当前合并实体有依赖关系的所有实体 包括当前实体
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        'MC',
        '[MC].[HC]'
    },
    'consol_task_id': '25ec16de-0ab8-4caa-a7c8-401d8ffb3051',
    'completed_entity'
    # 已经执行完合并逻辑的所有实体 不包括当前实体
    : {
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        '[MC].[HC]'
    },
    'submit_success_flag':True #数据是否已经提交 应该为True

}

import re

from Python.common.common_tools import PARENT_CHILD_PARSE
from Python.deep_consol.deep_consol import deep_consol as dc
from Python.deep_consol.journal_model import journal_model


def custom_process_control_post_python(p2):
    if p2.get("action") not in ["consolidation", "contribution"]:
        return
    if p2.get("completed_entity"):
        total_entity_list = [entity for entity in p2["completed_entity"] if re.match(PARENT_CHILD_PARSE, entity)]
        # 删除指定凭证
        if total_entity_list:
            t = journal_model.table
            where = ((t.year == p2['year']) &
                     (t.period == p2['period']) &
                     (t.scenario == p2['scenario']) &
                     (t.version == p2['version']) &
                     (t.value == "Elimination")) & \
                    (t.entity.isin(total_entity_list))

            r = journal_model.delete(where)
            print(r)
            # 构造凭证
            rlt = dc.journal_data()
            head_df = rlt[0]
            line_df = rlt[1]
            # 存入凭证模型
            if not head_df.empty and not line_df.empty:
                head_df['_type'] = 'sys_journal'
                r = journal_model.save(head_df=head_df,
                                       line_df=line_df,
                                       )
                print(r)

{
    'parent': None,
    'jobId': 'consol_process_9e364a47-5f83-44b3-a587-510e0f2af3df',
    'period': '10',
    'year': '2021',
    'scenario': 'Actual',
    'consolProcessElement': {
        'elementName': 'Consol_Process',
        'elementType': 'CONSOLPROC',
        'folderId': 'DIRcca5ba18db1d',
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\',
        'serverName': 'consolidation-process-server1-0'
    },
    'consolUnitContribution': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit_contribution',
        'tableName': 'eijuqd015_t_contribution_fk09y'
    },
    'consolUnit': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit',
        'tableName': 'eijuqd015_consol_unit_8ws4a'
    },
    'unitId': '2023_1_Actual_Working_TotalEntity',
    'version': 'Working',
    'entity': 'MC',
    # 执行逻辑的枚举：包括calculation、consolidation、consolidation_all、contribution、translation
    'action': 'consolidation',
    'target_vertex': 'MC',
    # 目标实体
    'all_entity': {
      # 与当前合并实体有依赖关系的所有实体 包括当前实体
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        'MC',
        '[MC].[HC]'
    },
    'consol_task_id': '25ec16de-0ab8-4caa-a7c8-401d8ffb3051',
    'completed_entity'
    # 已经执行完合并逻辑的所有实体 不包括当前实体
    : {
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        '[MC].[HC]'
    },
    'submit_success_flag':True #数据是否已经提交 可能为False
}

import re

from Python.common.common_tools import PARENT_CHILD_PARSE
from Python.deep_consol.deep_consol import deep_consol as dc
from Python.deep_consol.journal_model import journal_model


def custom_process_control_post_python_failed(p2):
    if p2.get("action") not in ["consolidation", "contribution"] and p2.get('submit_success_flag'):
        return
    if p2.get("completed_entity"):
        total_entity_list = [entity for entity in p2["completed_entity"] if re.match(PARENT_CHILD_PARSE, entity)]
        # 删除指定凭证
        if total_entity_list:
            t = journal_model.table
            where = ((t.year == p2['year']) &
                     (t.period == p2['period']) &
                     (t.scenario == p2['scenario']) &
                     (t.version == p2['version']) &
                     (t.value == "Elimination")) & \
                    (t.entity.isin(total_entity_list))

            r = journal_model.delete(where)
            print(r)
            # 构造凭证
            rlt = dc.journal_data()
            head_df = rlt[0]
            line_df = rlt[1]
            # 存入凭证模型
            if not head_df.empty and not line_df.empty:
                head_df['_type'] = 'sys_journal'
                r = journal_model.save(head_df=head_df,
                                       line_df=line_df,
                                       )
                print(r)

{
    'parent': None,
    'jobId': 'consol_process_9e364a47-5f83-44b3-a587-510e0f2af3df',
    'period': '10',
    'year': '2021',
    'scenario': 'Actual',
    'consolProcessElement': {
        'elementName': 'Consol_Process',
        'elementType': 'CONSOLPROC',
        'folderId': 'DIRcca5ba18db1d',
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\',
        'serverName': 'consolidation-process-server1-0'
    },
    'consolUnitContribution': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit_contribution',
        'tableName': 'eijuqd015_t_contribution_fk09y'
    },
    'consolUnit': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit',
        'tableName': 'eijuqd015_consol_unit_8ws4a'
    },
    'unitId': '2023_1_Actual_Working_TotalEntity',
    'version': 'Working',
    'entity': 'MC',
    # 执行逻辑的枚举：包括calculation、consolidation、contribution、translation
    'action': 'consolidation',
    'target_vertex': 'MC',
    # 目标实体
    'all_entity': {
         # 与当前合并实体有依赖关系的所有实体 包括当前实体
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        'MC',
        '[MC].[HC]'
    },
    'consol_task_id': '25ec16de-0ab8-4caa-a7c8-401d8ffb3051',
    'completed_entity'
    # 已经执行完合并逻辑的所有实体 不包括当前实体
    : {

    },
    'submit_success_flag':False #数据是否已经提交 应该为False
}

from Python.config import AsyncDataTable
async def custom_get_consol_custom_data_async(p2):
    table = AsyncDataTable(element_name='a')
    rlt = await table.select()
    return rlt

{
    'parent': None,
    'jobId': 'consol_process_9e364a47-5f83-44b3-a587-510e0f2af3df',
    'period': '10',
    'year': '2021',
    'scenario': 'Actual',
    'consolProcessElement': {
        'elementName': 'Consol_Process',
        'elementType': 'CONSOLPROC',
        'folderId': 'DIRcca5ba18db1d',
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\',
        'serverName': 'consolidation-process-server1-0'
    },
    'consolUnitContribution': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit_contribution',
        'tableName': 'eijuqd015_t_contribution_fk09y'
    },
    'consolUnit': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit',
        'tableName': 'eijuqd015_consol_unit_8ws4a'
    },
    'unitId': '2023_1_Actual_Working_TotalEntity',
    'version': 'Working',
    'entity': 'MC',
    # 执行逻辑的枚举：包括calculation、consolidation、contribution、translation
    'action': 'consolidation',
    'target_vertex': 'MC',
    # 目标实体
    'all_entity': {
         # 与当前合并实体有依赖关系的所有实体 包括当前实体
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        'MC',
        '[MC].[HC]'
    },
    'consol_task_id': '25ec16de-0ab8-4caa-a7c8-401d8ffb3051',
    'completed_entity'
    # 已经执行完合并逻辑的所有实体 不包括当前实体
    : {

    },
    'submit_success_flag':False #数据是否已经提交 应该为False
}

def custom_process_control_pre_python(p2):
    print(p2)
    

{
    'parent': None,
    'jobId': 'consol_process_9e364a47-5f83-44b3-a587-510e0f2af3df',
    'period': '10',
    'year': '2021',
    'scenario': 'Actual',
    'consolProcessElement': {
        'elementName': 'Consol_Process',
        'elementType': 'CONSOLPROC',
        'folderId': 'DIRcca5ba18db1d',
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\',
        'serverName': 'consolidation-process-server1-0'
    },
    'consolUnitContribution': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit_contribution',
        'tableName': 'eijuqd015_t_contribution_fk09y'
    },
    'consolUnit': {
        'path': '\\Consolidation_App\\Consol_Process\\UX_Process\\\\Consol_Process_tables_ywdy',
        'serverName': 'data-table-mysql-server1-0',
        'elementType': 'DAT_MYSQL',
        'folderId': 'DIRdf5a85392bd9',
        'elementName': 'consol_unit',
        'tableName': 'eijuqd015_consol_unit_8ws4a'
    },
    'unitId': '2023_1_Actual_Working_TotalEntity',
    'version': 'Working',
    'entity': 'MC',
    # 执行逻辑的枚举：包括calculation、consolidation、consolidation_all、contribution、translation
    'action': 'consolidation',
    'target_vertex': 'MC',
    # 目标实体
    'all_entity': {
      # 与当前合并实体有依赖关系的所有实体 包括当前实体
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        'MC',
        '[MC].[HC]'
    },
    'consol_task_id': '25ec16de-0ab8-4caa-a7c8-401d8ffb3051',
    'completed_entity'
    # 已经执行完合并逻辑的所有实体 不包括当前实体
    : {
        'M',
        'P',
        'C',
        'B',
        '[AC].[A]',
        '[HC].[E]',
        '[MC].[P]',
        '[AC].[BC]',
        '[HC].[F]',
        '[HC].[D]',
        '[MC].[AC]',
        'N',
        'D',
        '[MC].[M]',
        'BC',
        '[BC].[C]',
        'AC',
        'E',
        '[MC].[N]',
        'A',
        'HC',
        'F',
        '[BC].[B]',
        '[MC].[HC]'
    },
    'submit_success_flag':True #数据是否已经提交 可能为False
}

import re

def custom_process_control_python_after_each_entity_finished(p2):
    print(p2)

def custom_data_to_ec(dc):
    print(dc.cur_entity)
    from ..deepcube_config import get_main_cube
    from deepcube.dimension.dimension import ValueDim, PeriodDim, YearDim, VersionDim, \
        ScenarioDim, VerEntityDim, GenericDim, AccountDim, ViewDim
    main_cube = get_main_cube()
    from deepcube.cube.function import sum, round

    ye: YearDim = main_cube.year
    per: PeriodDim = main_cube.period
    sc: ScenarioDim = main_cube.scenario
    ver: VersionDim = main_cube.version
    en: VerEntityDim = main_cube.entity
    ac: AccountDim = main_cube.account
    val: ValueDim = main_cube.value
    d1: GenericDim = main_cube.d1
    view: ViewDim = main_cube.View

    main_cube.clear_scope()
    all_account_set = ac.root.Descendant()
    consolidated_account_set = all_account_set.loc[
        all_account_set.attr('ud2').isin(['true'])]

    all_d1_set = d1.root.Descendant()
    consolidated_d1_set = all_d1_set.loc[
        all_d1_set.attr('ud2').isin(['true'])]

    scopes = (en[dc.cur_entity],
              ye[dc.cur_year],
              per[dc.cur_period],
              sc[dc.cur_scenario],
              ver[dc.cur_version],
              val[dc.local_currency],
              consolidated_account_set,
              consolidated_d1_set,
              view['YTD'],
              )
    main_cube.scope(*scopes)
    main_cube.clear_data()
    child_member_list = ['[' + dc.node.member() + ']' + '.' + '[' + i + ']'
                         for i in dc.node.list(dc.node.member(), 'child')]
    main_cube.loc[val[dc.local_currency]] = round(sum(
        main_cube.loc[
            val['ContributionTotal'], en[child_member_list]]), 2)

def custom_data_to_ec_batch(dc):
    print(dc.cur_entity_set)
    from ..deepcube_config import get_main_cube
    from deepcube.dimension.dimension import ValueDim, PeriodDim, YearDim, VersionDim, \
        ScenarioDim, VerEntityDim, GenericDim, AccountDim, ViewDim
    main_cube = get_main_cube()
    from deepcube.cube.function import sum, round

    ye: YearDim = main_cube.year
    per: PeriodDim = main_cube.period
    sc: ScenarioDim = main_cube.scenario
    ver: VersionDim = main_cube.version
    en: VerEntityDim = main_cube.entity
    ac: AccountDim = main_cube.account
    val: ValueDim = main_cube.value
    d1: GenericDim = main_cube.d1
    view: ViewDim = main_cube.View

    main_cube.clear_scope()
    all_account_set = ac.root.Descendant()
    consolidated_account_set = all_account_set.loc[
        all_account_set.attr('ud2').isin(['true'])]
    
    all_d1_set = d1.root.Descendant()
    consolidated_d1_set = all_d1_set.loc[
        all_d1_set.attr('ud2').isin(['true'])]
    for cur_entity in dc.cur_entity_set:
        scopes = (en[cur_entity],
                  ye[dc.cur_year],
                  per[dc.cur_period],
                  sc[dc.cur_scenario],
                  ver[dc.cur_version],
                  val[dc.local_currency],
                  consolidated_account_set,
                  consolidated_d1_set,
                  view['YTD'],
                  )
        main_cube.scope(*scopes)
        main_cube.clear_data()
        child_member_list = ['[' + cur_entity + ']' + '.' + '[' + i + ']'
                            for i in dc.node.list(cur_entity, 'child')]
        main_cube.loc[val[dc.local_currency]] = round(sum(
            main_cube.loc[
                val['ContributionTotal'], en[child_member_list]]), 2)