cannect 1.0.0__py3-none-any.whl

cannect/core/testcase/testcase.py

@@ -0,0 +1,160 @@
+from cannect.config import env
+from cannect.core.testcase.unitcase import UnitTestCase
+from cannect.core.testcase.style import Style
+from datetime import datetime
+from pandas import DataFrame, ExcelWriter
+from typing import Dict, List, Hashable, Union
+import xlsxwriter as xlsx
+import os
+
+
+class TestCase:
+
+    def __init__(self, *args:UnitTestCase):
+        self._units: List[UnitTestCase] = []
+        self._template: str = env.SVN_CAN / "CAN_TestCase/TESTCASE_TEMPLATE.xlsm"
+        self._filename: str = f'TESTCASE @{str(datetime.now()).replace(" ", "_").replace(":", ";").split(".")[0]}'
+        self._data = ""
+        self._mdf = None
+        for arg in args:
+            self._units.append(arg)
+        return
+
+    def __repr__(self):
+        return repr(self.cases)
+
+    def __len__(self) -> int:
+        return len(self._units)
+
+    def __iter__(self):
+        for unit in self._units:
+            yield unit
+
+    def __getitem__(self, item: Union[int, str]) -> UnitTestCase:
+        if isinstance(item, int):
+            return self._units[item - 1]
+        elif isinstance(item, str):
+            for unit in self._units:
+                if unit["Test Case - ID"] == item:
+                    return unit
+        raise KeyError
+
+    def __setitem__(self, key: str, value):
+        for unit in self._units:
+            if not key in unit.index:
+                raise KeyError(f'Unknown key: {key}')
+            unit[key] = value
+        return
+
+    @property
+    def data(self) -> str:
+        return self._data
+
+    @data.setter
+    def data(self, data:str):
+        from pyems.mdf import MdfReader
+        self._data = data
+        self._mdf = MdfReader(data)
+        self["Measure / Log File (.dat)"] = os.path.basename(data)
+        return
+
+    @property
+    def filename(self) -> str:
+        return self._filename
+
+    @filename.setter
+    def filename(self, filename: str):
+        self._filename = filename
+
+    @property
+    def directory(self) -> str:
+        return str(env.DOWNLOADS / self.filename)
+
+    @property
+    def cases(self) -> DataFrame:
+        return DataFrame(self._units)
+
+    def append(self, case: UnitTestCase):
+        self._units.append(case)
+        return
+
+    def to_testcase(self, filename: Union[str, Hashable] = ""):
+        if filename:
+            self.filename = filename
+        with ExcelWriter(f"{self.directory}.xlsx", engine="xlsxwriter") as writer:
+            cases = self.cases.copy()
+            cases.to_excel(writer, sheet_name="Test Case", index=False)
+
+            wb, ws = writer.book, writer.sheets["Test Case"]
+            styler = Style(wb, ws)
+            for n, col in enumerate(cases.columns):
+                ws.write(0, n, col, styler.testcase_label[col])
+                for m, value in enumerate(cases[col]):
+                    ws.write(m + 1, n, value, styler.testcase_value[col])
+
+            for n, col in enumerate(cases.columns):
+                lens = len(col)
+                for val in cases[col]:
+                    vals = val.split('\n') if '\n' in str(val) else [str(val)]
+                    maxs = max([len(v) for v in vals])
+                    if maxs > lens:
+                        lens = maxs
+                ws.set_column(n, n, lens + 2)
+        return
+
+    def to_report(self, filename: Union[str, Hashable] = ""):
+        if filename:
+            self.filename = filename
+        file = f"{self.directory.replace('TestCase', 'TestReport')}.xlsx"
+        if not "TCU" in file and not "DATC" in file and "TC" in file:
+            file = file.replace("TC", "TR")
+
+        tc = xlsx.Workbook(filename=file)
+        ws = tc.add_worksheet(name="Test Report MLT")
+        ws.set_column('A:A', 1.63)
+        styler = Style(tc, ws)
+        styler.adjust_width()
+        for n, testcase in enumerate(self):
+            testcase.workbook = tc
+            testcase.to_report(1 + (n * 32))
+        tc.close()
+        return
+
+    def to_labfile(self, name: Union[str, Hashable] = ""):
+        filename = name if name else self.filename.replace("TESTCASE", "LABFILE")
+        if not filename.endswith(".lab"):
+            filename += ".lab"
+        file = env.DOWNLOADS / filename
+
+        elem, param = list(), list()
+        for _case in self._units:
+            for var in _case.variable:
+                box = param if var.endswith("_C") else elem
+                if not var in box:
+                    box.append(var)
+        EOL = "\n"
+        with open(file, "w", encoding="utf-8") as f:
+            f.write(f"""[SETTINGS]
+    Version;V1.1
+
+
+    [RAMCELL]
+    {EOL.join(sorted(elem))}
+
+
+    [LABEL]
+    {EOL.join(sorted(param))}
+    """)
+        return
+
+    def to_clipboard(self):
+        self.cases.to_clipboard(index=False)
+        return
+
+
+
+
+if __name__ == "__main__":
+    from emscan.core.testcase.unitcase import UnitTestCase
+    tc = TestCase(UnitTestCase())
+    tc.to_report()

cannect/core/testcase/unitcase.py

@@ -0,0 +1,227 @@
+from cannect.config import env
+from cannect.core.mdf import MdfReader
+from cannect.core.testcase.style import Style
+from cannect.core.testcase.plotter import Plot
+from numpy import nan
+from pandas import DataFrame, Series
+
+from typing import Any, Union, List
+from xlsxwriter import Workbook
+import warnings, os
+
+def custom_format(message, category, filename, lineno, line=None):
+    return f"{message}\n"
+warnings.formatwarning = custom_format
+
+LABEL = {
+    "NO": nan,
+    "Category": "UNIT",
+    "Group": "CAN",
+    "Test Case - ID": '',
+    "Test Case Name": '',
+    "Requirement - Traceability": '',
+    "Test Purpose, Description": '',
+    "PreCondition (PC) - Description": "B+ / IG1",
+    "PC-Variable": "BattU_u8\nIgKey_On",
+    "PC-Compare": ">\n=",
+    "PC-Value": "11.0\n1",
+    "Test Execution (TE) - Description": '',
+    "TE-Variable": '',
+    "TE-Compare": '',
+    "TE-Value": '',
+    "Expected Results (ER) - Description": '',
+    "ER-Variable": '',
+    "ER-Compare": '',
+    "ER-Value": '',
+    "Test Result": '',
+    "Test Result Description": '',
+    "Test Conductor": f"{env.KOREANAME} @HYUNDAI-KEFICO",
+    "Test SW": '',
+    "Test HW": '',
+    "Test Vehicle / Engine / HIL": '',
+    "Test Environment": '',
+    "Remark / Comment": '',
+    "Measure / Log File (.dat)": '',
+    "MDA Configuration File (.xda)": '',
+    "Experiment File (.exp)": '',
+    "VIO": '',
+    "SWC": '',
+    "MLT": "●",
+    "SLT": '',
+    "SDT": '',
+    "FDT": '',
+    "LVR": '',
+    "DCV": '',
+    "LSL": '',
+    "PSV": '',
+    "EOL": '',
+}
+
+
+class UnitTestCase(Series):
+
+    __wb__:Workbook = None
+    __dr__:MdfReader = None
+    __pg__:str = ''
+
+    def __init__(self, **kwargs):
+        self.__wb__ = None
+        self.__dr__ = None
+        self.__pg__ = ''
+
+        super().__init__({k: kwargs[k] if k in kwargs else v for k, v in LABEL.items()})
+        if 'workbook' in kwargs:
+            self.__wb__ = kwargs['workbook']
+        return
+
+    @property
+    def workbook(self) -> Union[Any, Workbook]:
+        return self.__wb__
+
+    @workbook.setter
+    def workbook(self, workbook: Workbook):
+        self.__wb__ = workbook
+
+    @property
+    def mdf(self) -> MdfReader:
+        return self.__dr__
+
+    @mdf.setter
+    def mdf(self, mdf:Union[str, MdfReader]):
+        if isinstance(mdf, str):
+            self.__dr__ = MdfReader(mdf)
+        else:
+            self.__dr__ = mdf
+        self["Measure / Log File (.dat)"] = os.path.basename(self.__dr__.file)
+        return
+
+    @property
+    def data(self) -> DataFrame:
+        if self.__dr__ is None:
+            return DataFrame()
+        vars = []
+        for var in self.variable:
+            if var.startswith("DEve"):
+                var = f"DEve_St.{var}"
+            if var.startswith("Fid"):
+                var = f"Fim_st.{var}"
+            if not var in self.mdf:
+                warnings.warn(
+                    f'#{self["Test Case - ID"]}의 {var}(이)가 측정 파일: {self.mdf.file}내 없습니다.',
+                    category=UserWarning
+                )
+                continue
+            vars.append(var)
+        return self.mdf[vars]
+
+    @property
+    def variable(self) -> List[str]:
+        var = []
+        for k, v in self.items():
+            if not str(k).endswith("Variable") or str(v) in ["nan", '']:
+                continue
+            for _v in v.split("\n"):
+                if not _v in var:
+                    var.append(_v)
+        return var
+
+    @property
+    def attachment(self) -> str:
+        return self.__pg__
+
+    @attachment.setter
+    def attachment(self, attachment:str):
+        self.__pg__ = attachment
+
+    def figure(self, **kwargs) -> Plot:
+        return Plot(self.data, **kwargs)
+
+    def to_report(self, row:int=1):
+        """
+        @param row: [int] 시작 행 번호
+        @param attach: [str] 그림 파일 경로
+        """
+        if isinstance(self.workbook, Workbook):
+            wb = self.workbook
+            ws = wb.worksheets_objs[0]
+        else:
+            # wb = self.workbook = Workbook(filename=PATH.DOWNLOADS.makefile(f"{self['Test Case Name']}.xlsx"))
+            wb = self.workbook = Workbook(filename=env.DOWNLOADS / f"{self['Test Case Name']}.xlsx")
+            ws = wb.add_worksheet(name="Test Report")
+            ws.set_column('A:A', 1.63)
+            for col in ["C", "F", "I", "L", "O"]:
+                ws.set_column(f'{col}:{col}', 3.13)
+            for col in ["B", "D", "E", "G", "H", "J", "K", "M", "N", "P"]:
+                ws.set_column(f'{col}:{col}', 13)
+
+        styler = Style(wb=wb, ws=ws)
+        ws.merge_range(f'B{row}:C{row}', 'Test Category', styler.report_label["Category"])
+        ws.merge_range(f'D{row}:E{row}', 'Test Group', styler.report_label["Group"])
+        ws.merge_range(f'F{row}:H{row}', 'Test Case ID', styler.report_label["Test Case - ID"])
+        ws.merge_range(f'I{row}:L{row}', 'Test Case Name', styler.report_label["Test Case Name"])
+        ws.merge_range(f'M{row}:P{row}', 'Requirement - Traceability', styler.report_label["Requirement - Traceability"])
+        ws.merge_range(f'B{row + 2}:D{row + 2}', 'Test Purpose', styler.report_label["Test Purpose, Description"])
+        ws.merge_range(f'E{row + 2}:G{row + 2}', 'Pre-Condition', styler.report_label["PreCondition (PC) - Description"])
+        ws.merge_range(f'H{row + 2}:J{row + 2}', 'Test Execution', styler.report_label["Test Execution (TE) - Description"])
+        ws.merge_range(f'K{row + 2}:M{row + 2}', 'Expected Result', styler.report_label["Expected Results (ER) - Description"])
+        ws.merge_range(f'N{row + 2}:P{row + 2}', 'Test Result', styler.report_label["Test Result"])
+        ws.merge_range(f'B{row + 5}:L{row + 5}', 'Test Result Graph', styler.report_label["Test Result Graph"])
+        ws.merge_range(f'M{row + 5}:P{row + 5}', '시험 결과 분석 / Comment / Remark', styler.report_label["Test Result Description"])
+        ws.merge_range(f'B{row + 27}:D{row + 27}', 'Test Conductor', styler.report_label["Test Conductor"])
+        ws.merge_range(f'E{row + 27}:G{row + 27}', 'Test SW', styler.report_label["Test SW"])
+        ws.merge_range(f'H{row + 27}:J{row + 27}', 'Test HW', styler.report_label["Test HW"])
+        ws.merge_range(f'K{row + 27}:M{row + 27}', 'Test Vehicle / Engine / HIL', styler.report_label["Test Case Name"])
+        ws.merge_range(f'N{row + 27}:P{row + 27}', 'Test Environment', styler.report_label["Test Environment"])
+        ws.merge_range(f'B{row + 29}:G{row + 29}', 'Remark / Comment', styler.report_label['Remark / Comment'])
+        ws.merge_range(f'H{row + 29}:J{row + 29}', 'Measure / Log File (.dat)', styler.report_label['Measure / Log File (.dat)'])
+        ws.merge_range(f'K{row + 29}:M{row + 29}', 'MDA Configuration File (.xda)', styler.report_label['MDA Configuration File (.xda)'])
+        ws.merge_range(f'N{row + 29}:P{row + 29}', 'Experiment File (.exp)', styler.report_label['Experiment File (.exp)'])
+        ws.merge_range(f'B{row + 1}:C{row + 1}', self['Category'], styler.report_value["Category"])
+        ws.merge_range(f'D{row + 1}:E{row + 1}', self['Group'], styler.report_value["Group"])
+        ws.merge_range(f'F{row + 1}:H{row + 1}', self['Test Case - ID'], styler.report_value["Test Case - ID"])
+        ws.merge_range(f'I{row + 1}:L{row + 1}', self['Test Case Name'], styler.report_value["Test Case Name"])
+        ws.merge_range(f'M{row + 1}:P{row + 1}', self['Requirement - Traceability'], styler.report_value["Requirement - Traceability"])
+        ws.merge_range(f'B{row + 3}:D{row + 4}', self['Test Purpose, Description'], styler.report_value["Test Purpose, Description"])
+        ws.merge_range(f'E{row + 3}:G{row + 3}', self['PreCondition (PC) - Description'], styler.report_value["PreCondition (PC) - Description"])
+        ws.write(f'E{row + 4}', self['PC-Variable'], styler.report_value["PC-Variable"])
+        ws.write(f'F{row + 4}', self['PC-Compare'], styler.report_value["PC-Compare"])
+        ws.write(f'G{row + 4}', self['PC-Value'], styler.report_value["PC-Value"])
+        ws.merge_range(f'H{row + 3}:J{row + 3}', self['Test Execution (TE) - Description'], styler.report_value["Test Execution (TE) - Description"])
+        ws.write(f'H{row + 4}', self['TE-Variable'], styler.report_value["TE-Variable"])
+        ws.write(f'I{row + 4}', self['TE-Compare'], styler.report_value["TE-Compare"])
+        ws.write(f'J{row + 4}', self['TE-Value'], styler.report_value["TE-Value"])
+        ws.merge_range(f'K{row + 3}:M{row + 3}', self['Expected Results (ER) - Description'], styler.report_value["Expected Results (ER) - Description"])
+        ws.write(f'K{row + 4}', self['ER-Variable'], styler.report_value["ER-Variable"])
+        ws.write(f'L{row + 4}', self['ER-Compare'], styler.report_value["ER-Compare"])
+        ws.write(f'M{row + 4}', self['ER-Value'], styler.report_value["ER-Value"])
+        ws.merge_range(f'N{row + 3}:P{row + 4}', self['Test Result'], styler.report_value["Test Result"])
+        ws.merge_range(f'B{row + 6}:L{row + 26}', '', styler.report_value["Test Result Graph"])
+        if self.attachment:
+            ws.insert_image(row + 5, 1, self.attachment, {
+                'x_offset': 0,
+                'y_offset': 0,
+                'x_scale': 0.4,
+                'y_scale': 0.4
+            })
+        ws.merge_range(f'M{row + 6}:P{row + 26}', self['Test Result Description'], styler.report_value['Test Result Description'])
+        ws.merge_range(f'B{row + 28}:D{row + 28}', self['Test Conductor'], styler.report_value['Test Conductor'])
+        ws.merge_range(f'E{row + 28}:G{row + 28}', self['Test SW'], styler.report_value['Test SW'])
+        ws.merge_range(f'H{row + 28}:J{row + 28}', self['Test HW'], styler.report_value['Test HW'])
+        ws.merge_range(f'K{row + 28}:M{row + 28}', self['Test Vehicle / Engine / HIL'], styler.report_value['Test Vehicle / Engine / HIL'])
+        ws.merge_range(f'N{row + 28}:P{row + 28}', self['Test Environment'], styler.report_value['Test Environment'])
+        ws.merge_range(f'B{row + 30}:G{row + 30}', self['Remark / Comment'], styler.report_value['Remark / Comment'])
+        ws.merge_range(f'H{row + 30}:J{row + 30}', self['Measure / Log File (.dat)'], styler.report_value['Measure / Log File (.dat)'])
+        ws.merge_range(f'K{row + 30}:M{row + 30}', self['MDA Configuration File (.xda)'], styler.report_value['MDA Configuration File (.xda)'])
+        ws.merge_range(f'N{row + 30}:P{row + 30}', self['Experiment File (.exp)'], styler.report_value['Experiment File (.exp)'])
+        for i in range(32):
+            ws.set_row(i + row, 48.5 if i == 2 else 19.25)
+
+        if not isinstance(self.workbook, Workbook):
+            wb.close()
+        return
+
+if __name__ == "__main__":
+    unit = UnitTestCase()
+    print(unit)
+    unit['Test Result'] = "PASS TEST"
+    print(unit)

cannect/errors.py

@@ -0,0 +1,20 @@
+class AmdDuplicationError(Exception):
+    pass
+
+class AmdFormatError(Exception):
+    pass
+
+class AmdNotFoundError(Exception):
+    pass
+
+class AscetWorspaceFormatError(Exception):
+    pass
+
+class CANDBError(Exception):
+    pass
+
+class InternalServerError(Exception):
+    pass
+
+class SVNError(Exception):
+    pass

cannect/schema/__init__.py

@@ -0,0 +1,5 @@
+from .datadictionary import DataDictionary
+
+
+# Alias
+dD = DD = DataDictionary

cannect/schema/candb.py

@@ -0,0 +1,226 @@
+from cannect.errors import CANDBError
+from pandas import DataFrame, Series
+from typing import Dict, List, Union
+import pandas as pd
+
+
+class CanSignal(object):
+    """
+    CAN DB의 단일 신호에 대한 정보 타입
+    """
+    def __init__(self, signal:Series):
+        self.signal = signal = signal.copy()
+        self.name = name = signal["Signal"]
+
+        # RPA 정보 연산
+        length, \
+        cycleTime, \
+        startValueInHex, \
+        factor, \
+        offset, \
+        valueType, \
+        signedProcessing = signal[[
+            "Length", "Cycle Time", "GenSigStartValue", "Factor", "Offset", "Value Type", "SignedProcessing"
+        ]]
+
+        # Physical Start Value (Initial Value)
+        signal["StartValue"] = int(startValueInHex, 16) * factor + offset
+
+        # Physical Minimum, Maximum Calculation
+        if valueType.lower() == "unsigned":
+            signal["physMax"] = factor * (2 ** length - 1) + offset
+            signal["physMin"] = offset
+        else:
+            if signedProcessing.lower() == "absolute":
+                signal["physMax"] = factor * (2 ** (length - 1) - 1) + offset
+                signal["physMin"] = (-1) * factor * (2 ** (length - 1) - 1) + offset
+            else:
+                signal["physMax"] = factor * (2 ** (length - 1) - 1) + offset
+                signal["physMin"] = (-1) * factor * (2 ** (length - 1)) + offset
+        return
+
+    def __getitem__(self, item):
+        return self.signal[item]
+
+    def __getattr__(self, item):
+        try:
+            return self.__getattribute__(item)
+        except AttributeError:
+            return getattr(self.signal, item)
+
+    def __str__(self) -> str:
+        """
+        :return:
+        출력 예시 ::
+            ECU                                                                            BMS
+            Message                                                                       BMS6
+            ID                                                                           0x51E
+            DLC                                                                            8.0
+            Send Type                                                                        P
+            Cycle Time                                                                   100.0
+            Signal                                                         CR_Bms_BatMinTemp_C
+            Definition                          Actual Minimum Temperature of 48V battery pack
+            Length                                                                         8.0
+            StartBit                                                                      40.0
+            Sig Receivers                                                                  EMS
+            UserSigValidity                                                                IG1
+            Value Table
+            Value Type                                                                  Signed
+            GenSigStartValue                                                              0x1E
+            Factor                                                                         1.0
+            Offset                                                                         0.0
+            Min                                                                         -128.0
+            Max                                                                          126.0
+            Unit                                                                          degC
+            Local Network Wake Up Request                                                   No
+            Network Request Holding Time                                                     0
+            Description                      This signal is for the 48V Battery System appl...
+            Version                                                                    1.04.05
+            Timeout                                                                       2000
+            ByteOrder                                                                    Intel
+            ICE Channel                                                                      L
+            ICE WakeUp
+            HEV Channel
+            HEV WakeUp
+            SystemConstant                                                MICROEPT_48V_SC == 1
+            Codeword                                                         Cfg_MeptSys_C > 0
+            Formula                                                                  T_Cels_q1
+            SignedProcessing                                                        Complement
+            InterfacedVariable                                                   Com_tBmsBatMn
+            SignalRenamed
+            History
+            Remark
+            Name: 100, dtype: object
+        """
+        return str(self.signal)
+
+    def isCrc(self) -> bool:
+        return (("crc" in self.name.lower()) and (self["StartBit"] == 0)) or \
+               ("checksum" in self.name.lower()) or \
+               ("chks" in self.name.lower()) or \
+               (self.name.startswith("VVDIN_EMS_CRC")) or \
+               (self.name.startswith("VVDIN_CRC"))
+
+    def isAliveCounter(self) -> bool:
+        if self.name == "HU_AliveStatus":
+            return False
+        return ((self["Message"] == "TMU_01_200ms") and (self.name == "VSVI_AlvCntVal")) or \
+               (("alv" in self.name.lower() or "alivec" in self.name.lower()) and self["StartBit"] <= 16) or \
+               ("alive" in self.name.lower()) or \
+               (self.name.startswith("VVDIN_EMS_CNT")) or \
+               (self.name.startswith("VVDIN_CNT")) or \
+               (self.name.lower().endswith("req_a_counter")) or \
+               ("A_Counter" in self.name)
+
+
+class CanMessage(object):
+    """
+    CAN DB의 단일 메시지에 대한 정보 타입
+    """
+
+    ITERATION_INCLUDES_ALIVECOUNTER:bool = False
+    ITERATION_INCLUDES_CRC:bool = False
+
+    def __init__(self, signals:DataFrame):
+        __attr__:Dict[str, Union[str, int, float]] = signals.iloc[0].to_dict()
+        __attr__['Version'] = signals["Version"].sort_values(ascending=True).iloc[-1]
+        if "E" in __attr__["Send Type"]:
+            if pd.isna(__attr__["Cycle Time"]):
+                raise CANDBError()
+            __attr__["taskTime"] = 0.04
+        else:
+            __attr__["taskTime"] = __attr__["Cycle Time"] / 1000
+
+        # ES SPEC TIMEOUT TIME
+        if __attr__["Cycle Time"] <= 50:
+            __attr__["timeoutTime"] = 0.5
+        elif __attr__["Cycle Time"] < 500:
+            __attr__["timeoutTime"] = 1.5
+        else:
+            __attr__["timeoutTime"] = 5.0
+
+        # NON-ES G-PROJECT EXCEPTION
+        if __attr__["Cycle Time"] == 1:
+            __attr__["timeoutTime"] = 0.25
+
+        self.__attr__ = __attr__
+        self.signals = signals
+        self.name = __attr__["Message"]
+        return
+
+    def __getitem__(self, item):
+        return self.__attr__[item]
+
+    def __iter__(self):
+        for _, row in self.signals.iterrows():
+            sig = CanSignal(row)
+            if sig.isCrc() and not self.ITERATION_INCLUDES_CRC:
+                continue
+            if sig.isAliveCounter() and not self.ITERATION_INCLUDES_ALIVECOUNTER:
+                continue
+            yield sig
+
+    def __len__(self):
+        return len(self.signals)
+
+    def __str__(self) -> str:
+        return str(Series(self.__attr__))
+
+    @property
+    def crc(self) -> Union[CanSignal, Series]:
+        revert = False
+        if not self.ITERATION_INCLUDES_CRC:
+            self.ITERATION_INCLUDES_CRC = revert = True
+        for sig in self:
+            if sig.isCrc():
+                if revert:
+                    self.ITERATION_INCLUDES_CRC = False
+                return sig
+        return Series()
+
+    @property
+    def aliveCounter(self) -> Union[CanSignal, Series]:
+        revert = False
+        if not self.ITERATION_INCLUDES_ALIVECOUNTER:
+            self.ITERATION_INCLUDES_ALIVECOUNTER = revert = True
+        for sig in self:
+            if sig.isAliveCounter():
+                if revert:
+                    self.ITERATION_INCLUDES_ALIVECOUNTER = False
+                return sig
+        return Series()
+
+    def hasCrc(self) -> bool:
+        if not hasattr(self, '__hascrc__'):
+            self.__setattr__('__hascrc__', not self.crc.empty)
+        return self.__getattribute__('__hascrc__')
+
+    def hasAliveCounter(self) -> bool:
+        if not hasattr(self, '__hasac__'):
+            self.__setattr__('__hasac__', not self.aliveCounter.empty)
+        return self.__getattribute__('__hasac__')
+
+    def isTsw(self) -> bool:
+        status = self.signals["Status"].unique().tolist()
+        return len(status) == 1 and status[0].lower() == "tsw"
+
+
+
+if __name__ == "__main__":
+
+    from pandas import read_json
+    from pandas import set_option
+    set_option('display.expand_frame_repr', False)
+
+
+    src = r'E:\SVN\dev.bsw\hkmc.ems.bsw.docs\branches\HEPG_Ver1p1\11_ProjectManagement\CAN_Database\dev\KEFICO-EMS_CANFD_V25.08.01.json'
+    rdb = read_json(src, orient='index')
+    # print(rdb)
+
+    # sig = CanSignal(rdb.iloc[100])
+    # print(sig)
+
+    msg = CanMessage(rdb[rdb["Message"] == 'HU_GW_PE_01'])
+    print(msg)
+    print(msg.hasAliveCounter())
+