mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/parallel/shard.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""shard"""
+"""pynative shard"""
 
 import copy
 import mindspore as ms
@@ -33,9 +33,6 @@ class Layout():
     Args:
         device_matrix (tuple): Describe the shape of devices arrangement, its element type is int.
         alias_name (tuple): The alias name for each axis of device_matrix, its length shoits element type is string.
-                            When using "interleaved_parallel" as an alias name, the tensor would be split into multiple
-                            copies on the corresponding partition dimension on a single card. The corresponding value
-                            of "interleaved_parallel" in device_matrix must be 2.
 
     Raises:
         TypeError: `device_matrix` is not a tuple type.
@@ -53,9 +50,6 @@ class Layout():
         >>> layout0 = layout("dp", "mp")
         >>> print(layout0.to_dict())
         {"device_matrix": (2, 2, 2), "tensor_map": (2, 0)}
-        >>> # Total device num is 4, but split the tensor in local device into two copies.
-        >>> layout = Layout((2, 2, 2), ("dp", "sp", "interleaved_parallel"))
-        >>> layout1 = layout(("dp", "interleaved_parallel"), "sp")
     """
 
     def __init__(self, device_matrix, alias_name):
@@ -77,13 +71,6 @@ class Layout():
                 raise ValueError(f"The element of alias_name can not set 'None', because 'None' means no sharding.")
         if len(set(alias_name)) != len(alias_name):
             raise ValueError(f'Each element of alias_name {alias_name} should be different')
-        inter_key = "interleaved_parallel"
-        if inter_key in alias_name and alias_name.index(inter_key) != len(alias_name) - 1:
-            raise ValueError(f"When alias_name {alias_name} contains keyword 'interleaved_parallel',"
-                             f" it should be at the last dim of alias_name, which means the virtual sharding.")
-        if inter_key in alias_name and device_matrix[alias_name.index(inter_key)] != 2:
-            raise ValueError(f"When alias_name {alias_name} contains keyword 'interleaved_parallel',"
-                             f" the corresponding dim of device_matrix should be 2.")
         self._device_shape = device_matrix
         self._alias_name = alias_name
         self._tensor_map = None
@@ -125,9 +112,7 @@ class Layout():
             raise ValueError("The device_shape of layout is None")
         if self._tensor_map is None:
             raise ValueError("The tensor_map of layout is None")
-        interleaved_parallel = "interleaved_parallel" in self._alias_name
-        return {"device_matrix": self._device_shape, "tensor_map": self._tensor_map,
-                "interleaved_parallel": interleaved_parallel}
+        return {"device_matrix": self._device_shape, "tensor_map": self._tensor_map}
 
 
 
@@ -146,17 +131,16 @@ class Shard(Shard_):
         self.level = None
 
     def __call__(self, fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascend", level=0):
-        parallel_mode = ms.context.get_auto_parallel_context("parallel_mode")
-        if parallel_mode not in ["auto_parallel", "semi_auto_parallel"]:
+        if ms.context.get_context("mode") != ms.context.PYNATIVE_MODE or \
+                ms.context.get_auto_parallel_context("parallel_mode") not in ["auto_parallel"]:
             raise AssertionError(
-                f"Cell shard only supports auto parallel and semi auto parallel.")
+                f"Cell shard only supports auto parallel under PyNative mode.")
         if ms.context.get_context("device_target") not in ["Ascend", "GPU"]:
             raise AssertionError(
                 f"'Shard' now only supports 'Ascend' and 'GPU'")
-        if parallel_mode == "auto_parallel" and \
-            ms.context.get_auto_parallel_context("search_mode") != "sharding_propagation":
-            raise AssertionError(f"'search_mode' must be 'sharding_propagation' for 'Shard' when the "
-                                 f"'parallel_mode' is 'auto_parallel.'")
+        if ms.context.get_auto_parallel_context("search_mode") != "sharding_propagation":
+            raise AssertionError(
+                f"'search_mode' must be 'sharding_propagation' for 'Shard'")
         if not isinstance(in_strategy, tuple):
             raise TypeError(
                 f"For 'Shard', the 'in_strategy' should be a tuple, but got {type(in_strategy).__name__}")
@@ -269,9 +253,8 @@ class Shard(Shard_):
 def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascend", level=0):
     """
     Defining the input and output layouts of this cell and the parallel strategies of remaining ops will be
-    generated by sharding propagation. In PyNative mode, use this method to specify a Cell for distributed
-    execution in graph mode. In Graph mode, use this method to specify distribution strategy for a Cell,
-    strategy for others will be set by sharding propagation.
+    generated by sharding propagation. In PyNative mode, use this method
+    to specify a Cell for distributed execution in graph mode.
     in_strategy and out_strategy define the input and output layout respectively.
     in_strategy/out_strategy should be a tuple, each element of which corresponds to the desired layout of
     this input/output, and None represents data_parallel,
@@ -279,8 +262,9 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
     The parallel strategies of remaining operators are derived from the strategy specified by the input and output.
 
     Note:
-        If ms.shard is called, the parallel mode in `set_auto_parallel_context` (parallel_mode) will be set to
-        "auto_parallel" and the search mode (search_mode) to "sharding_propagation".
+        You need to set the execution mode to PyNative mode,
+        set the parallel mode in `set_auto_parallel_context` (parallel_mode) to "auto_parallel"
+        and the search mode (search_mode) to "sharding_propagation".
         If the input contain Parameter, its strategy should be set in `in_strategy`.
 
     Args:
@@ -310,7 +294,9 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
         Function, return the function that will be executed under auto parallel process.
 
     Raises:
-        AssertionError: If parallel mode is not "auto_parallel" nor "semi_auto_parallel".
+        AssertionError: If execute mode is not PYNATIVE_MODE.
+        AssertionError: If parallel mode is not "auto_parallel".
+        AssertionError: If search_mode it not "sharding_propagation".
         AssertionError: If device_target it not "Ascend" or "GPU".
         TypeError: If `in_strategy` is not a tuple.
         TypeError: If `out_strategy` is not a tuple or None.
@@ -342,7 +328,7 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
 
     Tutorial Examples:
         - `Functional Operator Sharding
-          <https://www.mindspore.cn/tutorials/experts/en/master/parallel/shard_function_parallel.html>`_
+          <https://www.mindspore.cn/tutorials/experts/en/master/parallel/pynative_shard_function_parallel.html>`_
     """
     if not isinstance(fn, (ms.nn.Cell)):
         logger.warning("'fn' is not a mindspore.nn.Cell, and its definition cannot involve Parameter; "

mindspore/profiler/__init__.py

@@ -20,8 +20,7 @@ Users can visualize the results using the MindInsight tool.
 Now, Profiler supports AICORE operator, AICPU operator, HostCPU operator, memory,
 correspondence, cluster, etc data analysis.
 """
-__all__ = ["Profiler", "EnvProfiler", "ProfilerLevel"]
-
 from mindspore.profiler.profiling import Profiler
 from mindspore.profiler.envprofiling import EnvProfiler
-from mindspore.profiler.profiling import ProfilerLevel
+
+__all__ = ["Profiler", "EnvProfiler"]

mindspore/profiler/common/util.py

@@ -21,7 +21,6 @@ import os
 
 # one sys count takes 10 ns, 1 ms has 100000 system count
 import re
-import shutil
 import stat
 
 from mindspore import log as logger
@@ -321,11 +320,11 @@ def combine_stream_task_id(stream_id, task_id):
 
 
 def get_newest_file(file_list):
-    """
+    '''
     Find the newest files
     :param file_list:
     :return:
-    """
+    '''
     newest_file_list = []
     newest_timestamp = '0'
     for file_path in file_list:
@@ -338,107 +337,3 @@ def get_newest_file(file_list):
 
     newest_file_list.sort()
     return newest_file_list
-
-
-class ProfilerPathManager:
-    """A path manager to manage profiler path"""
-
-    FRAMEWORK_DIR = "FRAMEWORK"
-    INVALID_VALUE = -1
-
-    @classmethod
-    def get_fwk_path(cls, profiler_path: str) -> str:
-        """Get FRAMEWORK directory path"""
-        fwk_path = os.path.join(profiler_path, cls.FRAMEWORK_DIR)
-        if os.path.isdir(fwk_path):
-            return fwk_path
-        return ""
-
-    @classmethod
-    def get_cann_path(cls, profiler_path: str) -> str:
-        """Get CANN Prof directory path"""
-        sub_dirs = os.listdir(os.path.realpath(profiler_path))
-        for sub_dir in sub_dirs:
-            sub_path = os.path.join(profiler_path, sub_dir)
-            if os.path.isdir(sub_path) and re.match(r"^PROF_\d+_\d+_[0-9a-zA-Z]+", sub_dir):
-                return sub_path
-        return ""
-
-    @classmethod
-    def get_host_path(cls, cann_path: str) -> str:
-        """Get CANN Prof host directory path"""
-        host_path = os.path.join(cann_path, 'host')
-        if os.path.exists(host_path):
-            return host_path
-        return ""
-
-    @classmethod
-    def get_device_path(cls, cann_path: str) -> str:
-        """Get CANN Prof device directory path"""
-        sub_dirs = os.listdir(os.path.realpath(cann_path))
-        for sub_dir in sub_dirs:
-            sub_path = os.path.join(cann_path, sub_dir)
-            if os.path.isdir(sub_path) and re.match(r"^device_\d", sub_dir):
-                return sub_path
-        return ""
-
-    @classmethod
-    def remove_path_safety(cls, path: str):
-        """Remove directory"""
-        msg = f"Failed to remove path: {path}"
-        if os.path.islink(path):
-            raise RuntimeError(msg)
-        if not os.path.exists(path):
-            return
-        try:
-            shutil.rmtree(path)
-        except FileNotFoundError:
-            return
-        except Exception as err:
-            raise RuntimeError(msg) from err
-
-    @classmethod
-    def remove_file_safety(cls, file: str):
-        """Remove file"""
-        msg = f"Failed to remove file: {file}"
-        if os.path.islink(file):
-            raise RuntimeError(msg)
-        if not os.path.exists(file):
-            return
-        try:
-            os.remove(file)
-        except FileExistsError:
-            return
-        except Exception as err:
-            raise RuntimeError(msg) from err
-
-    @classmethod
-    def simplify_data(cls, profiler_path: str, simplify_flag: bool):
-        """Profiler simplify temporary data"""
-        cann_path = cls.get_cann_path(profiler_path)
-        device_path = cls.get_device_path(cann_path)
-        host_path = cls.get_host_path(cann_path)
-        rm_dirs = ['sqlite', 'summary', 'timeline'] if simplify_flag else ['sqlite']
-        for rm_dir in rm_dirs:
-            if device_path:
-                target_path = os.path.join(device_path, rm_dir)
-                cls.remove_path_safety(target_path)
-            if host_path:
-                target_path = os.path.join(host_path, rm_dir)
-                cls.remove_path_safety(target_path)
-        if simplify_flag:
-            fwk_path = cls.get_fwk_path(profiler_path)
-            cls.remove_path_safety(fwk_path)
-            if not cann_path:
-                return
-            cann_rm_dirs = ['analyze', 'mindstudio_profiler_log', 'mindstudio_profiler_output']
-            for cann_rm_dir in cann_rm_dirs:
-                target_path = os.path.join(cann_path, cann_rm_dir)
-                cls.remove_path_safety(target_path)
-            log_patten = r'msprof_anlysis_\d+\.log$'
-            for cann_file in os.listdir(cann_path):
-                file_path = os.path.join(cann_path, cann_file)
-                if not os.path.isfile(file_path):
-                    continue
-                if re.match(log_patten, cann_file):
-                    cls.remove_file_safety(file_path)

mindspore/profiler/envprofiling.py

@@ -160,7 +160,7 @@ def parse_ascend_args(options):
     if options.get("aicore_metrics") not in AICORE_METRICS_DICT:
         logger.warning(
             "The 'aicore_metrics' parameter of the environment variable MS_PROFILE_OPTIONS must be in "
-            f"[-1, 0, 1, 2, 3, 4, 5, 6], but got {options.get('aicore_metrics')}, it will be set to 0.")
+            f"[-1, 0, 1, 2, 3, 4, 5], but got {options.get('aicore_metrics')}, it will be set to 0.")
         options["aicore_metrics"] = 0
     if not isinstance(options.get("l2_cache"), bool):
         logger.warning(

mindspore/profiler/parser/ascend_analysis/constant.py

@@ -17,22 +17,26 @@
 
 class Constant:
     """Constant values"""
+    INVALID_VALUE = -1
+    NULL_VALUE = 0
 
-    HOST_TO_DEVICE = "HostToDevice"
-    START_FLOW = "s"
-    END_FLOW = "f"
-    META_EVENT = 'M'
-    COMPLETE_EVENT = 'X'
-    FLOW_OP = "flow"
-    INVALID_FLOW_ID = 18446744073709551615
+    # dir name
+    FRAMEWORK_DIR = "FRAMEWORK"
+    OUTPUT_DIR = "ASCEND_PROFILER_OUTPUT"
 
     # file authority
+    FILE_AUTHORITY = 0o640
+    DIR_AUTHORITY = 0o700
     MAX_FILE_SIZE = 1024 * 1024 * 1024 * 10
     MAX_CSV_SIZE = 1024 * 1024 * 1024 * 5
+    MAX_PATH_LENGTH = 4096
+    MAX_WORKER_NAME_LENGTH = 226
+    MAX_FILE_NAME_LENGTH = 255
+    PROF_WARN_SIZE = 1024 * 1024 * 1024
 
     # tlv constant struct
     FIX_SIZE_BYTES = "fix_size_bytes"
-    NS_TO_US = 1e-3
+    NS_TO_US = 1000
 
     # field name
     SEQUENCE_UNMBER = "Sequence number"
@@ -51,3 +55,12 @@ class Constant:
     PROCESS_SORT = "process_sort_index"
     THREAD_NAME = "thread_name"
     THREAD_SORT = "thread_sort_index"
+    FLOW_START_PH = "s"
+    FLOW_END_PH = "f"
+
+    ACL_OP_EXE_NAME = ("AscendCL@aclopCompileAndExecute".lower(), "AscendCL@aclopCompileAndExecuteV2".lower())
+    AI_CORE = "AI_CORE"
+
+    # profiler begin info
+    CANN_BEGIN_TIME = "collectionTimeBegin"
+    CANN_BEGIN_MONOTONIC = "clockMonotonicRaw"

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """Profiler file manager"""
-import csv
 import json
 import os.path
 from typing import List
@@ -76,84 +75,3 @@ class FileManager:
         flags = os.O_WRONLY | os.O_CREAT
         with os.fdopen(os.open(file_path, flags, cls.DATA_FILE_AUTHORITY), 'w') as fp:
             json.dump(json_data, fp, ensure_ascii=False)
-
-    @classmethod
-    def read_csv_file(cls, file_path: str) -> list:
-        """Read csv file and return list"""
-        if not os.path.isfile(file_path):
-            return []
-        file_size = os.path.getsize(file_path)
-        if file_size <= 0:
-            return []
-        if file_size > Constant.MAX_CSV_SIZE:
-            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
-            logger.warning(msg)
-            return []
-        result_data = []
-        try:
-            with open(file_path, newline="") as csv_file:
-                reader = csv.reader(csv_file)
-                for row in reader:
-                    result_data.append(row)
-        except Exception as err:
-            raise RuntimeError(f"Failed to read the file: {file_path}") from err
-        return result_data
-
-    @classmethod
-    def create_csv_file(cls, file_path: str, data: list, headers: list = None) -> None:
-        """Create csv file and write the data"""
-        if not data:
-            return
-        try:
-            with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT, 0o600),
-                           'w', newline="") as file:
-                writer = csv.writer(file)
-                if headers:
-                    writer.writerow(headers)
-                writer.writerows(data)
-        except Exception as err:
-            raise RuntimeError(f"Can't create file: {file_path}") from err
-
-    @classmethod
-    def combine_csv_file(cls, source_file_list: list, target_file_path: str, header_map: dict = None):
-        """Merge multiple CSV files into one"""
-        headers, all_data = [], []
-        for source_file in source_file_list:
-            data = cls.read_csv_file(source_file)
-            if len(data) > 1:
-                headers = data[0]
-                all_data.extend(data[1:])
-        if all_data:
-            if isinstance(header_map, dict):
-                headers = [header_map.get(header, header) for header in headers]
-            FileManager.create_csv_file(target_file_path, all_data, headers)
-
-    @classmethod
-    def get_csv_file_list_by_start_name(cls, source_path: str, start_name: str):
-        """Get all the csv files that match the name"""
-        file_list = []
-        for file_name in os.listdir(source_path):
-            if file_name.startswith(start_name) and file_name.endswith(".csv"):
-                file_list.append(os.path.join(source_path, file_name))
-        return file_list
-
-    @classmethod
-    def read_txt_file(cls, file_path: str) -> list:
-        """Read txt file and return list"""
-        if not os.path.isfile(file_path):
-            return []
-        file_size = os.path.getsize(file_path)
-        if file_size <= 0:
-            return []
-        if file_size > Constant.MAX_FILE_SIZE:
-            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
-            logger.warning(msg)
-            return []
-        result_data = []
-        try:
-            with open(file_path, "r") as file:
-                for line in file.readlines():
-                    result_data.append(line.strip().split(","))
-        except Exception as err:
-            raise RuntimeError(f"Failed to read the file: {file_path}") from err
-        return result_data

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Function event data struct."""
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 from enum import Enum
 from decimal import Decimal
 import struct
@@ -26,6 +26,10 @@ from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import Profi
 class BaseEvent(ABC):
     """Base class of CANNEvent and MindSporeOpEvent"""
 
+    HOST_TO_DEVICE = "HostToDevice"
+    START_FLOW = "s"
+    END_FLOW = "f"
+
     def __init__(self, data: Dict):
         if not isinstance(data, dict):
             raise TypeError("Input data must be dict.")
@@ -39,6 +43,7 @@ class BaseEvent(ABC):
         self.dur: float = 0.0
         self.args: Dict = {}
         self.parent: Optional[BaseEvent] = None
+        self.children: List[BaseEvent] = []
         self._init_params()
 
     @abstractmethod
@@ -50,6 +55,15 @@ class BaseEvent(ABC):
 class CANNEvent(BaseEvent):
     """Function event collected on the CANN side"""
 
+    def __init__(self, data: Dict):
+        self.unique_id = ""
+        self.is_ai_core = False
+        super().__init__(data)
+
+    @property
+    def is_comm_op(self):
+        return self.name.startswith("hcom_")
+
     def _init_params(self):
         """Initialize the attribute value of CANNEvent."""
         self.ts = Decimal(str(self._orig_data.get("ts", 0)))
@@ -60,54 +74,25 @@ class CANNEvent(BaseEvent):
         self.name = self._orig_data.get("name", "")
         self.id = self._orig_data.get("id", 0)
         self.args = self._orig_data.get("args", {})
-        self.ph = self._orig_data.get("ph")
-        self.cat = self._orig_data.get("cat")
+        self.unique_id = f"{self.pid}-{self.tid}-{str(self.ts)}"
+        self.is_ai_core = self.args.get("Task Type") == Constant.AI_CORE
 
     def is_flow_start_event(self) -> bool:
         """Determine whether the event is flow start event or not."""
-        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
-               self._orig_data.get("ph") == Constant.START_FLOW
+        return self._orig_data.get("cat") == self.HOST_TO_DEVICE and \
+            self._orig_data.get("ph") == self.START_FLOW
 
     def is_flow_end_event(self) -> bool:
         """Determine whether the event is flow end event or not."""
-        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
-               self._orig_data.get("ph") == Constant.END_FLOW
+        return self._orig_data.get("cat") == self.HOST_TO_DEVICE and \
+            self._orig_data.get("ph") == self.END_FLOW
 
     def is_x_event(self) -> bool:
         """Determine whether the event x event or not."""
         return self._orig_data.get("ph") == "X"
 
-    def to_json(self):
-        """Cast to trace event."""
-        if self.ph == Constant.META_EVENT:
-            res = {'name': self.name, 'pid': self.pid, 'tid': self.tid,
-                   'args': self.args, 'ph': self.ph}
-            if self.cat:
-                res.update({'cat': self.cat})
-            return res
-
-        if self.ph == Constant.COMPLETE_EVENT:
-            if self.parent is not None:
-                self.args.update({'mindspore_op': self.parent.name})
-            res = {'name': self.name, 'pid': self.pid, 'tid': self.tid,
-                   'ts': str(self.ts), 'dur': self.dur, 'args': self.args, 'ph': self.ph}
-            if self.cat:
-                res.update({'cat': self.cat})
-            return res
-
-        if self.ph == Constant.START_FLOW:
-            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
-                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat}
-
-        if self.ph == Constant.END_FLOW:
-            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
-                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat, 'bp': "e"}
-        return {'name': self.name, 'pid': self.pid, 'tid': self.tid,
-                'ts': str(self.ts), 'args': self.args, 'ph': self.ph}
-
 
 class MindSporeOpEnum(Enum):
-    """MindSporeOp index enum"""
     START_NS = 0
     END_NS = 1
     SEQUENCE_UNMBER = 2
@@ -115,9 +100,7 @@ class MindSporeOpEnum(Enum):
     START_THREAD_ID = 4
     END_THREAD_ID = 5
     FORWORD_THREAD_ID = 6
-    FLOW_ID = 7
-    STEP_ID = 8
-    IS_ASYNC = 9
+    IS_ASYNC = 7
 
 
 class MindSporeOpEvent(BaseEvent):
@@ -131,7 +114,11 @@ class MindSporeOpEvent(BaseEvent):
         Constant.OP_NAME: 3, Constant.INPUT_SHAPES: 5, Constant.INPUT_DTYPES: 4,
         Constant.CALL_STACK: 6, Constant.MODULE_HIERARCHY: 7, Constant.FLOPS: 8
     }
-    _fix_data_format = "<3q6Q?"
+    _fix_data_format = "<3q4Q?"
+
+    def __init__(self, data: Dict):
+        self.is_mindspore_op = True
+        super().__init__(data)
 
     def _init_params(self):
         """Initialize the attribute value of MindSporeOpEvent."""
@@ -142,8 +129,6 @@ class MindSporeOpEvent(BaseEvent):
         self.ts = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.START_NS.value])
         self.end_us = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])
         self.dur = self.end_us - self.ts
-        self.flow_id = int(fix_size_data[MindSporeOpEnum.FLOW_ID.value])
-        self.step = int(fix_size_data[MindSporeOpEnum.STEP_ID.value])
         self.args = self.__get_args(fix_size_data)
 
     def __get_args(self, fix_size_data) -> Dict:
@@ -155,7 +140,7 @@ class MindSporeOpEvent(BaseEvent):
             if type_name == Constant.OP_NAME or type_id not in self._orig_data.keys():
                 continue
             if type_name in set([Constant.INPUT_SHAPES, Constant.INPUT_DTYPES, Constant.CALL_STACK]):
-                args[type_name] = self._orig_data.get(type_id).replace("|", "\r\n")
+                args[type_name] = self._orig_data.get(type_id).replace(";", ";\r\n")
             else:
                 args[type_name] = self._orig_data.get(type_id)
         return args