deepfos 1.1.60__py3-none-any.whl → 1.1.78__py3-none-any.whl

deepfos/element/finmodel.py

@@ -9,11 +9,12 @@ from typing import (
 
 import numpy as np
 import pandas as pd
-from pydantic import Field, parse_obj_as
+from pydantic import Field
 from loguru import logger
 import datetime
 from multidict import MultiDict
 
+from deepfos.api.models import compat_parse_obj_as as parse_obj_as
 from .base import ElementBase, SyncMeta
 from .dimension import AsyncDimension, Dimension
 from .datatable import (
@@ -24,8 +25,10 @@ from deepfos.api.app import AppAPI
 from deepfos.lib.asynchronous import future_property
 from deepfos.lib.utils import (
     unpack_expr, dict_to_expr, LazyDict, expr_to_dict,
-    dict_to_sql, split_dataframe, find_str, concat_url, CIEnumMeta
+    dict_to_sql, find_str, concat_url, CIEnumMeta, ChunkAlert,
+    split_dataframe_alert,
 )
+from deepfos.lib.sysutils import complete_cartesian_product
 from deepfos.lib.constant import (
     DFLT_DATA_COLUMN, VIEW, VIEW_DICT,
     HIERARCHY, DECIMAL_COL, STRING_COL,
@@ -41,7 +44,8 @@ from deepfos.api.models.financial_model import (
     PcParams, CopyCalculateDTO,
     TaskExecutionParam,
     ParameterDefineDto,  # noqa
-    FinancialDataDto
+    FinancialDataDto,
+    SyncClearDataDto,
 )
 from deepfos.api.models.base import BaseModel
 from deepfos.options import OPTION
@@ -68,9 +72,12 @@ def need_query(body: str):
 
 # -----------------------------------------------------------------------------
 # models
+TypeDimensionExpr = Union[str, Dict[str, Union[List[str], str]]]
+
+
 class Description(BaseModel):
-    zh_cn: str = Field(None, alias='zh-cn')
-    en: Optional[str]
+    zh_cn: Optional[str] = Field(None, alias='zh-cn')
+    en: Optional[str] = None
 
 
 class DimensionInfo(BaseModel):
@@ -95,11 +102,11 @@ class DataTableInfo(BaseModel):
 
 
 class MDXVariableParameter(ParameterDefineDto):
-    type = 0
+    type: int = 0
 
 
 class MDXCubeParameter(ParameterDefineDto):
-    type = 1
+    type: int = 1
 
 
 class RoundType(int, Enum, metaclass=CIEnumMeta):
@@ -132,7 +139,11 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
 
     Args:
         entry_object: 数据来源名模板，支持替换的字段为脚本元素名称或脚本全名，默认为python
-
+        entry_mode: 数据来源类型，影响显示的icon，默认为1
+            1: Python
+            2: 电子表格
+            3: 可视化计算脚本
+            4: 数据流3.0
 
     Note:
 
@@ -172,11 +183,17 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
         folder_id: Optional[str] = None,
         path: Optional[str] = None,
         entry_object='python',
+        entry_mode=1,
         server_name: Optional[str] = None,
+        before_chunk: ChunkAlert = None,
+        after_chunk: ChunkAlert = None,
     ):
         full_name = OPTION.general.task_info.get('script_name', 'python')
         self.entry_object = entry_object.format(script_name=full_name.split('.')[-1],
                                                 full_name=full_name)
+        self.entry_mode = entry_mode
+        self.before_chunk = before_chunk
+        self.after_chunk = after_chunk
         super().__init__(element_name, folder_id, path, server_name)
 
     @future_property(on_demand=True)
@@ -377,6 +394,7 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
         verify_access: bool = False,
         include_ignored: bool = False,
         normalize_view: bool = False,
+        pivot_members: List[str] = None,
     ) -> Union[pd.DataFrame, Tuple[pd.DataFrame, Dict[str, str]]]:
         """
         根据维度表达式以及pov获取cube数据
@@ -390,6 +408,7 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
             verify_access: 是否带权限查询
             include_ignored: 包含多版本实体维时，是否在结果中包含无效数据(即i列为1的数据)
             normalize_view: 是否把大小写View统一成"View"
+            pivot_members: 如有透视维度，可指定透视成员列表，在透视列成员不存在时补全列
 
         .. admonition:: 示例
 
@@ -419,7 +438,9 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
 
         """
         pov = self._resolve_pov_as_dict(pov, validate_expr)
-        expression, full_pov = self._split_expr(expression, pov, validate_expr=validate_expr)
+        expression, full_pov = self._split_expr(
+            expression, pov, validate_expr=validate_expr
+        )
         pov_expr = dict_to_expr(full_pov)
 
         if not expression:  # only pov
@@ -456,10 +477,17 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
 
         if pivot_dim is not None:
             pivot_col = self._get_column_from_dim(pivot_dim)
-
+            has_mbrs = isinstance(pivot_members, list)
+            if has_mbrs and any(not isinstance(c, str) for c in pivot_members):
+                raise ValueError(
+                    f"Pivot members must be a list of string, got: {pivot_members}"
+                )
             if pivot_col in full_pov:
                 val = full_pov.pop(pivot_col)
-                data = data.rename(columns={DFLT_DATA_COLUMN: val})
+                if not has_mbrs or val in pivot_members:
+                    data = data.rename(columns={DFLT_DATA_COLUMN: val})
+                else:
+                    data = data.drop(columns=[DFLT_DATA_COLUMN])
             elif pivot_col not in data.columns:
                 raise ValueError(
                     f"Pivot dimension: {pivot_dim} does not "
@@ -475,55 +503,28 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
                     columns=pivot_col, aggfunc='first', fill_value=None
                 ).reset_index(drop=drop_index)
                 data.columns.name = None
-
+                if has_mbrs:
+                    data = data.drop(columns=filter(
+                        lambda c: c not in pivot_members and c not in index,
+                        data.columns
+                    ))
+            if has_mbrs:
+                mbr_assigns = {m: None for m in pivot_members if m not in data.columns}
+                data = data.assign(**mbr_assigns)
         if not compact:
             return data.assign(**full_pov)
         return data, full_pov
 
-    async def save(
+    def _build_dataframe_for_save(
         self,
         data: pd.DataFrame,
         pov: Optional[Union[str, Dict[str, str]]] = None,
         data_column: str = DFLT_DATA_COLUMN,
-        need_check: bool = True,
-        data_audit: bool = True,
-        chunksize: Optional[int] = None,
-        callback: bool = True,
         comment_column: str = DFLT_COMMENT_COLUMN,
-        auth_mode: Literal[0, 1, 2, 3] = 0,
-    ):
-        """
-        将DataFrame的数据保存至cube。
-
-        Args:
-            data: 需要保存的数据
-            pov: Point Of View，维度表达式或者KV键值对格式。
-            data_column: 数据列的列名
-            need_check: 是否需要java接口校验脏数据
-            data_audit: 是否需要记录到数据审计
-            chunksize: 单次调用保存接口时最大的dataframe行数。
-              当data的行数超过此值时，将会分多次进行保存。
-            callback: 是否回调
-            comment_column: 备注列的列名，默认为VirtualMeasure_220922
-            auth_mode: 数据保存权鉴模式，默认为0，模式对应如下:
-                - 0: 继承财务模型权鉴模式
-                - 1: 宽松模式
-                - 2: 严格模式
-                - 3: 普通模式
-
-        Note:
-            此方法会对落库数据做以下处理：
-
-            - 列名重命名：维度名->数据表列名
-            - 忽略多余数据列
-
-        See Also:
-            :meth:`save_unpivot`
-
-        """
+    ) -> Tuple[pd.DataFrame, Dict[str, str]]:
         if data.empty:
             logger.info("Will not save to cube because dataframe is empty.")
-            return
+            return pd.DataFrame(), {}
 
         if data_column not in data.columns:
             raise ValueError(f"Missing data column: {data_column}.")
@@ -570,11 +571,190 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
             data = pd.concat([data, cmt_data])
             required_cols.add(COLUMN_USAGE_FIELD)
 
+        return data[list(required_cols)], pov
+
+    async def save(
+        self,
+        data: pd.DataFrame,
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        data_column: str = DFLT_DATA_COLUMN,
+        need_check: bool = True,
+        data_audit: bool = True,
+        chunksize: Optional[int] = None,
+        callback: bool = True,
+        comment_column: str = DFLT_COMMENT_COLUMN,
+        auth_mode: Literal[0, 1, 2, 3] = 0,
+    ):
+        """
+        将DataFrame的数据保存至cube。
+
+        Args:
+            data: 需要保存的数据
+            pov: Point Of View，维度表达式或者KV键值对格式。
+            data_column: 数据列的列名
+            need_check: 是否需要java接口校验脏数据
+            data_audit: 是否需要记录到数据审计
+            chunksize: 单次调用保存接口时最大的dataframe行数。
+              当data的行数超过此值时，将会分多次进行保存。
+            callback: 是否回调
+            comment_column: 备注列的列名，默认为VirtualMeasure_220922
+            auth_mode: 数据保存权鉴模式，默认为0，模式对应如下:
+                - 0: 继承财务模型权鉴模式
+                - 1: 宽松模式
+                - 2: 严格模式
+                - 3: 普通模式
+
+        Note:
+            此方法会对落库数据做以下处理：
+
+            - 列名重命名：维度名->数据表列名
+            - 忽略多余数据列
+
+        See Also:
+            :meth:`save_unpivot`
+            :meth:`complement_save`
+            :meth:`complement_save_unpivot`
+
+        """
+        data, pov = self._build_dataframe_for_save(data, pov, data_column, comment_column)
+        if data.empty:
+            return
+
         return await self._save_impl(
-            data[list(required_cols)],
-            pov, need_check, data_audit, chunksize, callback, auth_mode
+            data, pov, need_check, data_audit, chunksize, callback, auth_mode
+        )
+
+    def _complement(
+        self,
+        data: pd.DataFrame,
+        expression: str,
+        default_hierarchy: str = 'Base',
+        pov: Dict[str, str] = None,
+    ):
+        if isinstance(expression, dict):
+            expression = dict_to_expr(expression)
+        expr, pov = self._split_expr(expression, pov or {}, default_hierarchy)
+        full_expr = {**expr_to_dict(expr), **pov}
+        folders = {col: dim.folderId for col, dim in self.dimensions.items()}
+        data_comp = complete_cartesian_product(
+            full_expr,
+            data,
+            folder_ids=folders,
+            col_dim_map=self.col_dim_map,
+        )
+        return data_comp
+
+    async def complement_save(
+        self,
+        data: pd.DataFrame,
+        expression: Union[str, Dict[str, Union[List[str], str]]],
+        default_hierarchy: str = "Base",
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        data_column: str = DFLT_DATA_COLUMN,
+        comment_column: str = DFLT_COMMENT_COLUMN,
+        **kwargs
+    ):
+        """覆盖指定维度范围并保存数据
+
+        相比于 :meth:`save` ，在保存前，会将`data`按照`expression`补全笛卡尔积。
+        并且不在`data`范围的数据以`None`填充
+
+        Note:
+            逻辑上等价于两次调用
+
+            .. code-block:: python
+
+                cube.delete(expression)
+                cube.save(data, pov, data_column, comment_column, **kwargs)
+
+        Args:
+            data: 需要保存的数据
+            expression: 需要覆盖的范围（维度表达式）
+            default_hierarchy: 当expression中没指定对应维度时，默认取的层级函数，
+                即填充为 `default_hierarchy(#root,0)`
+            pov: Point Of View，维度表达式或者KV键值对格式。
+            data_column: 数据列的列名
+            comment_column: 备注列的列名，默认为VirtualMeasure_220922
+            **kwargs: 其他可传给 :meth:`save`的参数
+
+        See Also:
+            :meth:`save`
+            :meth:`save_unpivot`
+            :meth:`complement_save_unpivot`
+
+        """
+        if not self._backend_del_availiable:
+            return await self._legacy_complement_save(
+                data=data,
+                expression=expression,
+                default_hierarchy=default_hierarchy,
+                pov=pov,
+                data_column=data_column,
+                comment_column=comment_column,
+                **kwargs
+            )
+
+        await self.delete(
+            expression,
+            data_audit=False,
+            default_hierarchy=default_hierarchy
+        )
+        await self.save(
+            data=data,
+            pov=pov,
+            data_column=data_column,
+            comment_column=comment_column,
+            **kwargs,
         )
 
+
+    async def _legacy_complement_save(
+        self,
+        data: pd.DataFrame,
+        expression: Union[str, Dict[str, Union[List[str], str]]],
+        default_hierarchy: str = "Base",
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        data_column: str = DFLT_DATA_COLUMN,
+        comment_column: str = DFLT_COMMENT_COLUMN,
+        **kwargs
+    ):
+        data, pov = self._build_dataframe_for_save(data, pov, data_column, comment_column)
+        if data.empty:
+            return
+
+        data_comp = self._complement(data, expression, default_hierarchy, pov)
+        return await self._save_impl(data_comp, pov, **kwargs)
+
+    def _build_dataframe_for_save_unpivot(
+        self,
+        data: pd.DataFrame,
+        unpivot_dim: str,
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        save_nan: bool = False,
+    ) -> Tuple[pd.DataFrame, Dict[str, str]]:
+        if data.empty:
+            logger.info("Will not save to cube because dataframe is empty.")
+            return pd.DataFrame(), {}
+
+        data = data.rename(columns=self._maybe_get_column_from_dim)
+        dim = self._get_column_from_dim(unpivot_dim)
+        pov = self._resolve_pov_as_dict(pov)
+        data_cols = set(data.columns)
+        unpivot_cols = data_cols.difference(pov.keys(), self.dim_col_map.values())
+        if self._meta.autoCalculation:
+            unpivot_cols.discard(VIEW)
+        id_cols = data_cols - unpivot_cols
+        data = data.melt(
+            id_vars=id_cols, value_vars=unpivot_cols,
+            var_name=dim, value_name=DFLT_DATA_COLUMN
+        )
+        if not save_nan:
+            data = data.dropna()
+            if data.empty:
+                logger.info("Will not save to cube because dataframe is empty.")
+                return pd.DataFrame(), {}
+        return data, pov
+
     async def save_unpivot(
         self,
         data: pd.DataFrame,
@@ -621,35 +801,98 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
             | :meth:`save`
 
         """
+        data, pov = self._build_dataframe_for_save_unpivot(
+            data, unpivot_dim, pov, save_nan
+        )
         if data.empty:
-            logger.info("Will not save to cube because dataframe is empty.")
             return
 
-        data = data.rename(columns=self._maybe_get_column_from_dim)
-        dim = self._get_column_from_dim(unpivot_dim)
-        pov = self._resolve_pov_as_dict(pov)
-        data_cols = set(data.columns)
-        unpivot_cols = data_cols.difference(pov.keys(), self.dim_col_map.values())
+        return await self._save_impl(
+            data, pov, need_check, data_audit, chunksize, callback
+        )
 
-        if self._meta.autoCalculation:
-            unpivot_cols.discard(VIEW)
+    async def complement_save_unpivot(
+        self,
+        data: pd.DataFrame,
+        unpivot_dim: str,
+        expression: Union[str, Dict[str, Union[List[str], str]]],
+        default_hierarchy: str = "Base",
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        save_nan: bool = False,
+        **kwargs
+    ):
+        """覆盖指定维度范围并保有某个维度所有成员在列上的 ``DataFrame``
 
-        id_cols = data_cols - unpivot_cols
-        data = data.melt(
-            id_vars=id_cols, value_vars=unpivot_cols,
-            var_name=dim, value_name=DFLT_DATA_COLUMN
-        )
+        相比于:meth:`save_unpivot`，在保存前，会将`data`按照`expression`补全笛卡尔积。
+        并且不在`data`范围的数据以`None`填充
 
-        if not save_nan:
-            data = data.dropna()
-            if data.empty:
-                logger.info("Will not save to cube because dataframe is empty.")
-                return
+        Note:
+            逻辑上等价于两次调用
 
-        return await self._save_impl(
-            data, pov, need_check, data_audit, chunksize, callback
+            .. code-block:: python
+
+                cube.delete(expression)
+                cube.save_unpivot(data, unpivot_dim, **kwargs)
+
+        Args:
+            data: 需要保存的数据
+            unpivot_dim: 成员在列上的维度
+            expression: 需要覆盖的范围（维度表达式）
+            default_hierarchy: 单expression中没指定对应维度时，默认取的层级函数，
+                即填充为 `default_hierarchy(#root,0)`
+            pov: Point Of View，维度表达式或者KV键值对格式。
+            save_nan: 当把数据列成员转换到行上时，data为空的数据是否保存
+            **kwargs: 其他可传给 :meth:`save_unpivot`的参数
+
+        See Also:
+            :meth:`save`
+            :meth:`save_unpivot`
+            :meth:`complement_save`
+
+        """
+        if not self._backend_del_availiable:
+            return await self._legacy_complement_save_unpivot(
+                data=data,
+                unpivot_dim=unpivot_dim,
+                expression=expression,
+                default_hierarchy=default_hierarchy,
+                pov=pov,
+                save_nan=save_nan,
+                **kwargs
+            )
+
+        await self.delete(
+            expression,
+            data_audit=False,
+            default_hierarchy=default_hierarchy
+        )
+        await self.save_unpivot(
+            data=data,
+            unpivot_dim=unpivot_dim,
+            pov=pov,
+            save_nan=save_nan,
+            **kwargs,
         )
 
+    async def _legacy_complement_save_unpivot(
+        self,
+        data: pd.DataFrame,
+        unpivot_dim: str,
+        expression: Union[str, Dict[str, Union[List[str], str]]],
+        default_hierarchy: str = "Base",
+        pov: Optional[Union[str, Dict[str, str]]] = None,
+        save_nan: bool = False,
+        **kwargs
+    ):
+        data, pov = self._build_dataframe_for_save_unpivot(
+            data, unpivot_dim, pov, save_nan
+        )
+        if data.empty:
+            return
+
+        data_comp = self._complement(data, expression, default_hierarchy, pov)
+        return await self._save_impl(data_comp, pov, **kwargs)
+
     async def _save_impl(
         self,
         data: pd.DataFrame,
@@ -661,36 +904,47 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
         auth_mode: Literal[0, 1, 2, 3] = 0,
     ):
         # replace NaN to standard None
-        data = data.mask(data.isna(), None)
+        # NB: replace twice in case of infer None to nan happened in 2.x pandas
+        data[DFLT_DATA_COLUMN] = data[DFLT_DATA_COLUMN].replace({None: np.nan})
+        data[DFLT_DATA_COLUMN] = data[DFLT_DATA_COLUMN].replace({np.nan: None})
         # ensure view is capitalized
         if self._meta.autoCalculation:
             data = data.rename(columns=VIEW_DICT)
+
+        cols = list(data.columns)
+        if dup_cols := set([c for c in cols if cols.count(c) > 1]):
+            raise ValueError(f"Duplicate columns:{dup_cols} found in data.")
+
         # save data
         resp = []
-        for batch_data in split_dataframe(data, chunksize):
-            row_data = [
-                {"columnDimensionMemberMap": row}
-                for row in bp.dataframe_to_dict(batch_data)
-            ]
-            payload = ReactSpreadsheetSaveForm(
-                entryObject=self.entry_object,
-                sheetDatas=[SpreadsheetSingleData(
-                    cubeName=self.element_info.elementName,
-                    cubeFolderId=self.element_info.folderId,
-                    rowDatas=row_data,
-                    commonMember=pov,
-                )],
-                needCheck=need_check,
-                dataAuditSwitch=data_audit,
-                entryMode=1,
-                validateDimensionMember=need_check,
-                callback=callback,
-                saveDataAuthMode=auth_mode
-            )
-            r = await self.async_api.reactspreadsheet.save(
-                payload.dict(exclude_unset=True)
-            )
-            resp.append(r)
+
+        for batch_data, alert in split_dataframe_alert(
+            data, chunksize, self.before_chunk, self.after_chunk
+        ):
+            with alert:
+                row_data = [
+                    {"columnDimensionMemberMap": row}
+                    for row in bp.dataframe_to_dict(batch_data)
+                ]
+                payload = ReactSpreadsheetSaveForm(
+                    entryObject=self.entry_object,
+                    sheetDatas=[SpreadsheetSingleData(
+                        cubeName=self.element_info.elementName,
+                        cubeFolderId=self.element_info.folderId,
+                        rowDatas=row_data,
+                        commonMember=pov,
+                    )],
+                    needCheck=need_check,
+                    dataAuditSwitch=data_audit,
+                    entryMode=self.entry_mode,
+                    validateDimensionMember=need_check,
+                    callback=callback,
+                    saveDataAuthMode=auth_mode
+                )
+                r = await self.async_api.reactspreadsheet.save(
+                    payload.dict(exclude_unset=True)
+                )
+                resp.append(r)
         return resp
 
     async def delete_with_mdx(
@@ -816,12 +1070,33 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
 
         return await self.mdx_execution(script)
 
+    @future_property
+    async def _server_version(self) -> Tuple[int, ...]:
+        api: FinancialModelAPI = await self.wait_for('async_api')
+        version = await api.extra.git_version()
+        if version.lower().startswith('v'):
+            version = version[1:]
+        parts = []
+        for part in version.split('.'):
+            try:
+                parts.append(int(part))
+            except (TypeError, ValueError):
+                continue
+        return tuple(parts)
+
+    @future_property
+    async def _backend_del_availiable(self):
+        version = await self.__class__._server_version.wait_for(self)
+        return version >= (1, 1, 1, 2, 1)
+
     async def delete(
         self,
-        expression: Union[str, Dict[str, Union[List[str], str]]],
+        expression: Union[TypeDimensionExpr, List[TypeDimensionExpr]],
         chunksize: Optional[int] = None,
         use_mdx: bool = False,
-        callback: bool = True
+        callback: bool = False,
+        data_audit: bool = True,
+        default_hierarchy: str = "Base",
     ):
         """删除数据
 
@@ -838,6 +1113,9 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
               当data的行数超过此值时，将会分多次进行保存。
             use_mdx: 是否使用MDX脚本实现，默认为否，等效于调用 :meth:`delete_with_mdx`
             callback: 是否回调
+            data_audit: 是否记录审计日志
+            default_hierarchy: 当expression中没指定对应维度时，默认取的层级函数，
+                即填充为 `default_hierarchy(#root,0)`
 
         .. admonition:: 示例
 
@@ -862,6 +1140,63 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
             :meth:`insert_null` :meth:`delete_with_mdx`
 
         """
+        if (
+            not self._backend_del_availiable
+            or use_mdx
+            or callback
+        ):
+            if isinstance(expression, list):
+                raise ValueError(
+                    f"pass expresssion as list is not yet supported. "
+                    f"backend version: {self._server_version}")
+            return await self._legacy_delete(
+                expression,
+                chunksize=chunksize,
+                use_mdx=use_mdx,
+                callback=callback,
+                data_audit=data_audit,
+            )
+
+        if not isinstance(expression, list):
+            expression = [expression]
+
+        clear_scopes = []
+        for expr in expression:
+            if isinstance(expr, dict):
+                expr = dict_to_expr(expr)
+
+            expr_str, pov = self._split_expr(
+                expr, {},
+                default_hierarchy=default_hierarchy,
+                validate_expr=True
+            )
+            expr_parts = []
+            if expr_str:
+                expr_parts.append(expr_str)
+            if pov:
+                expr_parts.append(dict_to_expr(pov))
+
+            clear_scopes.append("->".join(expr_parts))
+
+        return await self.async_api.calculate.clear_data_ex(
+            SyncClearDataDto(
+                cubeName=self.element_name,
+                folderId=self.element_info.folderId,
+                clearScriptList=clear_scopes,
+                entryMode=self.entry_mode,
+                entryObject='python',
+                dataAuditSwitch=data_audit
+            )
+        )
+
+    async def _legacy_delete(
+        self,
+        expression: Union[str, Dict[str, Union[List[str], str]]],
+        chunksize: Optional[int] = None,
+        use_mdx: bool = False,
+        callback: bool = True,
+        data_audit: bool = True,
+    ):
         if use_mdx:
             return await self.delete_with_mdx(expression)
 
@@ -876,7 +1211,7 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
         data, pov = await self.query(expression)
         data[DFLT_DATA_COLUMN] = None
         return await self.save(
-            data, pov, data_audit=True, chunksize=chunksize, callback=callback
+            data, pov, data_audit=data_audit, chunksize=chunksize, callback=callback
         )
 
     async def queries(
@@ -1312,13 +1647,82 @@ class AsyncFinancialCube(ElementBase[FinancialModelAPI]):
 
         return res
 
+    async def mdx_execution_with_code(
+        self,
+        script_code: str,
+        parameters: Optional[Dict[str, str]] = None,
+        precision: Optional[int] = None,
+        timeout: Optional[int] = None,
+        round_type: Union[RoundType, str] = RoundType.floor,
+    ):
+        """通过提供MDX计算脚本编码执行对应的MDX计算脚本
+
+        Args:
+            script_code: MDX计算脚本编码
+            parameters: MDX执行所需的标量参数信息键值对
+            precision: 计算精度，默认为财务模型小数精度
+            timeout: 超时时间(ms)，默认为180秒(与OPTION.api.timeout保持一致)，
+                     如为None，则为接口的默认值60秒，
+                     目前该接口不支持设置为无限等待执行结果
+            round_type: 小数保留类型，默认为去尾法
+
+        Returns:
+            执行结果
+
+        """
+
+        if timeout is None:
+            timeout = OPTION.api.timeout * 1000
+
+        params = []
+
+        if parameters is not None:
+            if not isinstance(parameters, dict):
+                raise TypeError('parameters参数应为字典')
+
+            for key, value in parameters.items():
+                params.append(MDXVariableParameter(key=key, value=value))
+
+        path = self._path
+
+        if path is None:
+            path = await AppAPI(sync=False).folder.get_folder_full(
+                self.element_info.folderId
+            )
+
+        path = path.replace('\\', '/').rstrip('/') + '/'
+
+        res = await self.async_api.mdxtask.execution(
+            TaskExecutionParam(
+                businessId=script_code,
+                decimalDigitsType=RoundType[round_type],
+                parameters=params,
+                precision=precision,
+                timeout=timeout,
+                scriptCode=script_code,
+                cubeName=self.element_info.elementName,
+                cubeFolderId=self.element_info.folderId,
+                cubePath=path
+            )
+        )
+
+        if res.status == 1:
+            raise MDXExecuteTimeout(f'MDX执行超时，具体响应:\n{res}')
+
+        if res.result is False:
+            raise MDXExecuteFail(f'MDX执行失败，失败原因:\n{res.failReason}')
+
+        return res
+
 
 class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
     synchronize = (
         'query',
         'queries',
         'save',
+        'complement_save',
         'save_unpivot',
+        'complement_save_unpivot',
         'delete',
         'delete_with_mdx',
         'pc_init',
@@ -1326,7 +1730,8 @@ class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
         'pc_upsert',
         'insert_null',
         'copy_calculate',
-        'mdx_execution'
+        'mdx_execution',
+        'mdx_execution_with_code',
     )
 
     if TYPE_CHECKING:   # pragma: no cover
@@ -1348,6 +1753,7 @@ class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
             verify_access: bool = False,
             include_ignored: bool = False,
             normalize_view: bool = False,
+            pivot_members: List[str] = None,
         ) -> Union[pd.DataFrame, Tuple[pd.DataFrame, Dict[str, str]]]:
             ...
 
@@ -1365,6 +1771,17 @@ class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
         ):
             ...
 
+        def complement_save(
+            self,
+            data: pd.DataFrame,
+            expression: Union[str, Dict[str, Union[List[str], str]]],
+            pov: Optional[Union[str, Dict[str, str]]] = None,
+            data_column: str = DFLT_DATA_COLUMN,
+            comment_column: str = DFLT_COMMENT_COLUMN,
+            **kwargs
+        ):
+            ...
+
         def save_unpivot(
             self,
             data: pd.DataFrame,
@@ -1378,12 +1795,26 @@ class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
         ):
             ...
 
+        def complement_save_unpivot(
+            self,
+            data: pd.DataFrame,
+            unpivot_dim: str,
+            expression: Union[str, Dict[str, Union[List[str], str]]],
+            default_hierarchy: str = "Base",
+            pov: Optional[Union[str, Dict[str, str]]] = None,
+            save_nan: bool = False,
+            **kwargs
+        ):
+            ...
+
         def delete(
             self,
             expression: Union[str, Dict[str, Union[List[str], str]]],
             chunksize: Optional[int] = None,
             use_mdx: bool = False,
-            callback: bool = True
+            callback: bool = True,
+            data_audit: bool = True,
+            default_hierarchy: str = "Base",
         ):
             ...
 
@@ -1443,6 +1874,16 @@ class FinancialCube(AsyncFinancialCube, metaclass=SyncMeta):
         ):
             ...
 
+        def mdx_execution_with_code(
+            self,
+            script_code: str,
+            parameters: Optional[Dict[str, str]] = None,
+            precision: Optional[int] = None,
+            timeout: Optional[int] = None,
+            round_type: Union[RoundType, str] = RoundType.floor,
+        ):
+            ...
+
     @cached_property
     def dim_elements(self) -> LazyDict[str, Dimension]:
         """财务Cube的维度元素