mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/experimental/llm_boost/atb/llama_boost.py

@@ -1,137 +0,0 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""llm boost"""
-import json
-import mindspore.common.dtype as mstype
-from mindspore.experimental.llm_boost.atb.boost_base import (
-    AtbBoostBase,
-    PositionEmbeddingType,
-    NormType,
-)
-from mindspore._c_expression import LlmBoostBinder
-from mindspore.experimental.llm_boost.register import LlmBoostRegister, LlmBoostType
-
-CPP_LLAMA_MODEL_CLASS_NAME = "llama_LlamaDecoderModel"
-
-
-@LlmBoostRegister.register(LlmBoostType.BUILDIN, "Llama")
-class LlamaBoost(AtbBoostBase):
-    """LlamaBoost class"""
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.in_tensor_length = 13
-        self.acl_encoder_operation_inputs = [None] * self.in_tensor_length
-        self.acl_decoder_operation_inputs = [None] * self.in_tensor_length
-        self.atb_encoder_operation = LlmBoostBinder(
-            self.backend_name, CPP_LLAMA_MODEL_CLASS_NAME
-        )
-        self.atb_decoder_operation = LlmBoostBinder(
-            self.backend_name, CPP_LLAMA_MODEL_CLASS_NAME
-        )
-
-    def init(self):
-        """
-        Initialize the object
-        returns True if object needs input manipulation by mindformers
-        """
-
-        coder_param = {
-            "normEps": self.config.rms_norm_eps,
-            "normType": NormType.RMS_NORM,
-            "numAttentionHeadsPerRank": self.config.num_heads // self.device_num,
-            "hiddenSizePerAttentionHead": self.head_dim,
-            "numHiddenLayers": self.num_layers,
-            "numKeyValueHeadsPerRank": self.n_kv_heads // self.device_num,
-            "skipWordEmbedding": False,
-            "isFA": False,
-            "isBF16": self.dtype == mstype.bfloat16,
-            "packQuantType": [[1, 1] for _ in range(self.num_layers)],
-            "linearQuantType": [
-                [0, -1, -1, 0, 0, -1, 0] for _ in range(self.num_layers)
-            ],
-            "linearTransposeType": [
-                [1, -1, -1, 1, 1, -1, 1] for i in range(self.num_layers)
-            ],
-            "isEmbeddingParallel": False,
-            "isLmHeadParallel": not self.config.parallel_config.vocab_emb_dp,
-            "lmHeadTransposeType": 1,
-            "enableSwiGLU": True,
-            "enablekvQuant": self.kv_quant is not None,
-            "rank": self.rank_id,
-            "worldSize": self.device_num,
-            "backend": self.config.communication_backend,
-            "rankTableFile": "",
-            "positionEmbeddingType": PositionEmbeddingType.ROPE,
-            "hiddenSize": self.config.hidden_size,
-            "gemma": False,
-            "enableAddNorm": False,
-            "enableCompressHead": False,
-            "isUnpadInputs": True,
-        }
-        encoder_param = {
-            **coder_param,
-            "isPrefill": True,
-            "enableLcoc": True,
-            "enableSpeculate": False,
-            "skipWordEmbedding": False,
-            "enableSplitFuse": False,
-        }
-        decoder_param = {
-            **coder_param,
-            "isPrefill": False,
-            "enableLcoc": False,
-            "enableSpeculate": False,
-        }
-        self.atb_encoder_operation.init(json.dumps({**encoder_param}))
-        self.atb_decoder_operation.init(json.dumps({**decoder_param}))
-        return True
-
-    def _prepare_inputs(
-            self,
-            prefill=None,
-            input_ids=None,
-            position_ids=None,
-            cos_embed=None,
-            sin_embed=None,
-            attention_mask=None,
-            block_tables=None,
-            slots=None,
-            input_lengths=None,
-            lm_head_indices=None,
-            seqLen=None,
-            **kwargs
-    ):
-        """prepare inputs"""
-        self.acl_param = json.dumps(
-            {
-                "seqLen": seqLen,
-            }
-        )
-
-        self.acl_decoder_operation_inputs[0] = input_ids
-        self.acl_decoder_operation_inputs[1] = self.placeholder
-        self.acl_decoder_operation_inputs[2] = position_ids
-        self.acl_decoder_operation_inputs[3] = cos_embed
-        self.acl_decoder_operation_inputs[4] = sin_embed
-        self.acl_decoder_operation_inputs[5] = attention_mask
-        self.acl_decoder_operation_inputs[6] = block_tables
-        self.acl_decoder_operation_inputs[7] = slots
-        self.acl_decoder_operation_inputs[8] = self.placeholder
-        self.acl_decoder_operation_inputs[9] = self.placeholder
-        self.acl_decoder_operation_inputs[10] = self.placeholder
-        self.acl_decoder_operation_inputs[11] = input_lengths
-        self.acl_decoder_operation_inputs[12] = lm_head_indices
-        return self.acl_decoder_operation_inputs, self.acl_param

mindspore/experimental/llm_boost/atb/qwen_boost.py

@@ -1,124 +0,0 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""llm boost"""
-import json
-import mindspore.common.dtype as mstype
-from mindspore.experimental.llm_boost.atb.boost_base import AtbBoostBase, NormType
-from mindspore._c_expression import LlmBoostBinder
-from mindspore.experimental.llm_boost.register import LlmBoostRegister, LlmBoostType
-
-
-CPP_QWEN_MODEL_CLASS_NAME = "qwen_QwenDecoderModel"
-
-
-@LlmBoostRegister.register(LlmBoostType.BUILDIN, "Qwen")
-class QwenBoost(AtbBoostBase):
-    """QwenBoost class"""
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.in_tensor_length = 12
-        self.acl_encoder_operation_inputs = [None] * self.in_tensor_length
-        self.acl_decoder_operation_inputs = [None] * self.in_tensor_length
-        self.atb_encoder_operation = LlmBoostBinder(
-            self.backend_name, CPP_QWEN_MODEL_CLASS_NAME
-        )
-        self.atb_decoder_operation = LlmBoostBinder(
-            self.backend_name, CPP_QWEN_MODEL_CLASS_NAME
-        )
-
-    def init(self):
-        """set param"""
-        param_dict = {
-            "isFA": False,
-            "isBF16": self.dtype == mstype.bfloat16,
-            "withEmbedding": True,
-            "isEmbeddingParallel": True,
-            "isLmHeadParallel": True,
-            "linearTransposeType": [
-                [1, -1, -1, 1, 1, -1, 1] for i in range(self.num_layers)
-            ],
-            "lmHeadTransposeType": 1,
-            "enableSwiGLU": not self.need_nz,
-            "normEps": self.config.rms_norm_eps,
-            "normType": NormType.RMS_NORM,
-            "numAttentionHeadsPerRank": self.config.num_heads // self.device_num,
-            "hiddenSizePerAttentionHead": self.head_dim,
-            "numHiddenLayers": self.num_layers,
-            "numKeyValueHeadsPerRank": self.n_kv_heads // self.device_num,
-            "rank": self.rank_id,
-            "worldSize": self.device_num,
-            "backend": self.config.communication_backend,
-            "packQuantType": [[1, 1] for _ in range(self.num_layers)],
-            "linearQuantType": [
-                [0, -1, -1, 0, 0, -1, 0] for _ in range(self.num_layers)
-            ],
-            "linearHasBias": [[True, False, False, False]] * self.num_layers,
-            "enableKvQuant": self.kv_quant is not None,
-            "enableLora": False,
-            "isUnpadInputs": True,
-            "enableAddNorm": False,
-        }
-        encoder_param = {
-            **param_dict,
-            "isPrefill": True,
-            "enableLcoc": False,
-            "enableSplitFuse": False,
-        }
-        decoder_param = {
-            **param_dict,
-            "isPrefill": False,
-            "enableLcoc": False,
-            "enableSpeculate": False,
-            "enablePrefixCache": False,
-        }
-        self.atb_encoder_operation.init(json.dumps({**encoder_param}))
-        self.atb_decoder_operation.init(json.dumps({**decoder_param}))
-
-    def _prepare_inputs(
-            self,
-            prefill=None,
-            input_ids=None,
-            position_ids=None,
-            cos_embed=None,
-            sin_embed=None,
-            attention_mask=None,
-            block_tables=None,
-            slots=None,
-            input_lengths=None,
-            lm_head_indices=None,
-            seqLen=None,
-            **kwargs
-    ):
-        """prepare inputs"""
-        self.acl_param = json.dumps(
-            {
-                "seqLen": seqLen,
-            }
-        )
-
-        self.acl_decoder_operation_inputs[0] = input_ids
-        self.acl_decoder_operation_inputs[1] = position_ids
-        self.acl_decoder_operation_inputs[2] = cos_embed
-        self.acl_decoder_operation_inputs[3] = sin_embed
-        self.acl_decoder_operation_inputs[4] = attention_mask
-        self.acl_decoder_operation_inputs[5] = block_tables
-        self.acl_decoder_operation_inputs[6] = slots
-        self.acl_decoder_operation_inputs[7] = self.placeholder
-        self.acl_decoder_operation_inputs[8] = self.placeholder
-        self.acl_decoder_operation_inputs[9] = self.placeholder
-        self.acl_decoder_operation_inputs[10] = input_lengths
-        self.acl_decoder_operation_inputs[11] = lm_head_indices
-        return self.acl_decoder_operation_inputs, self.acl_param

mindspore/experimental/llm_boost/register.py

@@ -1,130 +0,0 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""LlmBoostRegister"""
-import inspect
-
-
-class LlmBoostType:
-    """Class module type for vision pretrain"""
-
-    def __init__(self):
-        pass
-
-    BUILDIN = 'BuildIn'
-    ASCEND_NATIVE = 'LLMBoost'
-
-
-class LlmBoostRegister:
-    """
-    Module class factory.
-    """
-
-    def __init__(self):
-        pass
-
-    registry = {}
-
-    @classmethod
-    def register(cls, boost_type=LlmBoostType.BUILDIN, alias=None):
-        """Register class into registry
-        Args:
-            boost_type:
-                boost type name, default LlmBoostType.BUILDIN
-            alias (str) : model_name
-
-        Returns:
-            wrapper
-        """
-
-        def wrapper(register_class):
-            """Register-Class with wrapper function.
-
-            Args:
-                register_class : class need to register
-
-            Returns:
-                wrapper of register_class
-            """
-            model_name = alias if alias is not None else register_class.__name__
-            if boost_type not in cls.registry:
-                cls.registry[boost_type] = {model_name: register_class}
-            else:
-                cls.registry[boost_type][model_name] = register_class
-            return register_class
-
-        return wrapper
-
-    @classmethod
-    def is_exist(cls, boost_type, model_name=None):
-        """Determine whether class name is in the current type group.
-
-        Args:
-            boost_type : Module type
-            model_name : model name
-
-        Returns:
-            True/False
-        """
-        if not model_name:
-            return boost_type in cls.registry
-        registered = boost_type in cls.registry and model_name in cls.registry.get(
-            boost_type)
-        return registered
-
-    @classmethod
-    def get_cls(cls, boost_type, model_name=None):
-        """Get class
-
-        Args:
-            boost_type : Module type
-            model_name : model name
-
-        Returns:
-            register_class
-        """
-        if not cls.is_exist(boost_type, model_name):
-            raise ValueError("Can't find class type {} class name {} \
-            in class registry".format(boost_type, model_name))
-
-        if not model_name:
-            raise ValueError(
-                "Can't find model. model name = {}".format(model_name))
-        register_class = cls.registry.get(boost_type).get(model_name)
-        return register_class
-
-    @classmethod
-    def get_instance(cls, boost_type=LlmBoostType.BUILDIN, model_name=None, **kwargs):
-        """Get instance.
-        Args:
-            boost_type : module type
-            model_name : model type
-        Returns:
-            object : The constructed object
-        """
-        if model_name is None:
-            raise ValueError("Class name cannot be None.")
-
-        if isinstance(model_name, str):
-            obj_cls = cls.get_cls(boost_type, model_name)
-        elif inspect.isclass(model_name):
-            obj_cls = model_name
-        else:
-            raise ValueError("Can't find boost type {} model name {} \
-            in class registry.".format(boost_type, model_name))
-
-        try:
-            return obj_cls(**kwargs)
-        except Exception as e:
-            raise type(e)('{}: {}'.format(obj_cls.__name__, e))

mindspore/experimental/llm_boost/utils.py

@@ -1,31 +0,0 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""LlmBoostRegister"""
-import os
-from mindspore.communication import get_group_size, get_rank
-
-
-def get_real_rank():
-    try:
-        return get_rank()
-    except RuntimeError:
-        return int(os.getenv("RANK_ID", "0"))
-
-
-def get_real_group_size():
-    try:
-        return get_group_size()
-    except RuntimeError:
-        return int(os.getenv("RANK_SIZE", "1"))

mindspore/include/OWNERS

@@ -1,7 +0,0 @@
-approvers:
-- jpc_chenjianping #
-- zhang_xue_tong
-reviewers:
-- lx0095
-- xu-yfei
-- wilfchen

mindspore/nn/optim/_dist_optimizer_registry.py

@@ -1,111 +0,0 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""_dist_optimizer_registry"""
-from __future__ import absolute_import
-
-from inspect import isfunction
-
-from mindspore.parallel._ps_context import _get_ps_context, _is_ps_mode
-
-
-_create_func_map = {}
-
-
-def _register_dist_optimizer(optimizer_type, creating_func):
-    """
-    Register distributed optimizers.
-    This method should be called by original optimizers.
-    """
-    if optimizer_type in _create_func_map:
-        return
-    if not isfunction(creating_func):
-        raise TypeError("creating_func is not a function type!")
-    _create_func_map[optimizer_type] = creating_func
-
-
-def empty_creating_func(*args, **kwargs):
-    """Empty function as placeholder."""
-    return
-
-
-_pserver_optmizer_attrs = {
-    "ms_role": "MS_PSERVER",
-    "primitive_target": "CPU",
-    "update_parameter": True
-}
-
-
-def create_optimizers_on_pserver(optimizer_type, parameters, *args, **kwargs):
-    """
-    Create the optimizers on parameter server.
-    This method should be called only in Parameter Server training mode.
-    Return distributed optimizer list and the flag list which indicates whether the parameters use them.
-    The size of the two lists returned should be the same as the size of input 'parameters'
-    """
-    distributed_optimizer_list = []
-    use_flag_list = []
-    for index, param in enumerate(parameters):
-        if param.is_param_ps and (not param.cache_enable):
-            if optimizer_type not in _create_func_map:
-                raise ValueError("Optimizer type %s is not recognized!" % optimizer_type)
-            distributed_optimizer = _create_func_map.get(optimizer_type)(*args, **kwargs)
-
-            server_rank_id = index % _get_ps_context("server_num")
-            distributed_optimizer.add_prim_attr("rank_id", server_rank_id)
-            for key, value in _pserver_optmizer_attrs.items():
-                distributed_optimizer.add_prim_attr(key, value)
-            distributed_optimizer_list.append(distributed_optimizer)
-            use_flag_list.append(True)
-        else:
-            distributed_optimizer_list.append(empty_creating_func)
-            use_flag_list.append(False)
-    return distributed_optimizer_list, use_flag_list
-
-
-def no_distributed_optimizer(optimizer_type, parameters, *args, **kwargs):
-    """
-    In some cases, no distributed optimizers are needed.
-    But we still need to return lists so optimizer subclasses can build the network using HyperMap.
-    """
-    empty_list = []
-    use_flag_list = []
-    for _ in parameters:
-        empty_list.append(empty_creating_func)
-        use_flag_list.append(False)
-    return empty_list, use_flag_list
-
-
-def get_creating_func():
-    """
-    Returns creating functions for distributed optimizers.
-    """
-    # Only support optimizers in parameter server mode for now.
-    if _is_ps_mode():
-        return create_optimizers_on_pserver
-    return no_distributed_optimizer
-
-
-def generate_dist_optimizer_list(optimizer_type, parameters, *args, **kwargs):
-    """
-    Generate the distributed optimizers according to the execution mode.
-    Only Parameter Server training mode is supported for now.
-    """
-    func = get_creating_func()
-    opt_list, use_flag_list = func(optimizer_type, parameters, *args, **kwargs)
-    if len(opt_list) != len(parameters) or len(use_flag_list) != len(parameters):
-        raise ValueError(f"Size of distributed optimizer list should be the same as parameter list. "
-                         f"But got len(opt_list):{len(opt_list)}"
-                         f", len(parameters):{len(parameters)}")
-    return opt_list, tuple(use_flag_list)

mindspore/nn/reinforcement/_batch_read_write.py

@@ -1,142 +0,0 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-BatchReadWrite
-"""
-from __future__ import absolute_import
-
-from mindspore.nn.cell import Cell
-from mindspore.ops.operations._rl_inner_ops import BatchAssign
-
-
-class BatchWrite(Cell):
-    r"""BatchWrite: write a list of parameters to assign the target.
-
-    .. warning::
-        This is an experiential prototype that is subject to change and/or deletion.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import nn
-        >>> from mindspore.common.parameter import Parameter, ParameterTuple
-        >>> from mindspore.nn.reinforcement import BatchWrite
-        >>> class SourceNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(SourceNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.5, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1, weight_init=0)
-        >>> class DstNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(DstNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.1, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1)
-        >>> class Write(nn.Cell):
-        ...   def __init__(self, dst, src):
-        ...     super(Write, self).__init__()
-        ...     self.w = BatchWrite()
-        ...     self.dst = ParameterTuple(dst.trainable_params())
-        ...     self.src = ParameterTuple(src.trainable_params())
-        ...   def construct(self):
-        ...     success = self.w(self.dst, self.src)
-        ...     return success
-        >>> dst_net = DstNet()
-        >>> source_net = SourceNet()
-        >>> nets = nn.CellList()
-        >>> nets.append(dst_net)
-        >>> nets.append(source_net)
-        >>> success = Write(nets[0], nets[1])()
-    """
-    def __init__(self):
-        """Initialize BatchWrite"""
-        super(BatchWrite, self).__init__()
-        self.write = BatchAssign(lock=True)
-
-    def construct(self, dst, src):
-        """
-        Write the source parameter list to assign the dst.
-
-        Inputs:
-            - **dst** (tuple) - A paramameter tuple of the dst model.
-            - **src** (tuple) - A paramameter tuple of the source model.
-
-        Returns:
-            Bool, true.
-        """
-        self.write(dst, src)
-        return True
-
-
-class BatchRead(Cell):
-    r"""BatchRead: read a list of parameters to assign the target.
-
-    .. warning::
-        This is an experiential prototype that is subject to change and/or deletion.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import nn
-        >>> from mindspore.common.parameter import Parameter, ParameterTuple
-        >>> from mindspore.nn.reinforcement import BatchRead
-        >>> class SNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(SNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.5, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1, weight_init=0)
-        >>> class DNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(DNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.1, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1)
-        >>> class Read(nn.Cell):
-        ...   def __init__(self, dst, src):
-        ...     super(Read, self).__init__()
-        ...     self.read = BatchRead()
-        ...     self.dst = ParameterTuple(dst.trainable_params())
-        ...     self.src = ParameterTuple(src.trainable_params())
-        ...   def construct(self):
-        ...     success = self.read(self.dst, self.src)
-        ...     return success
-        >>> dst_net = DNet()
-        >>> source_net = SNet()
-        >>> nets = nn.CellList()
-        >>> nets.append(dst_net)
-        >>> nets.append(source_net)
-        >>> success = Read(nets[0], nets[1])()
-
-    """
-    def __init__(self):
-        """Initialize BatchRead"""
-        super(BatchRead, self).__init__()
-        self.read = BatchAssign(lock=False)
-
-    def construct(self, dst, src):
-        """
-        Read the source parameter list to assign the dst.
-
-        Inputs:
-            - **dst** (tuple) - A paramameter tuple of the dst model.
-            - **src** (tuple) - A paramameter tuple of the source model.
-
-        Returns:
-            Bool, true.
-        """
-        self.read(dst, src)
-        return True