cannect 1.0.0__py3-none-any.whl

cannect/core/can/ascet/_db2elem.py

@@ -0,0 +1,399 @@
+from cannect.config import env
+from cannect.core.ascet.oid import generateOID
+from cannect.core.ascet.amd import AmdElements
+from cannect.core.ascet.formula import formula_dictionary
+from cannect.core.can.ascet import _db2code
+from cannect.core.can.rule import naming
+from cannect.schema.candb import CanMessage, CanSignal
+from cannect.schema.datadictionary import DataDictionary
+from cannect.utils.tools import xml
+
+from typing import Dict, Iterator, Optional, Union
+from xml.etree.ElementTree import Element
+import math
+
+
+F = formula_dictionary(env.SVN_CAN / "CAN_Model/Formula/HNB_I4GDI_I4MPI.xml")
+
+def elementWrapper(**kwargs) -> DataDictionary:
+    return DataDictionary(
+        kwargs=DataDictionary(**kwargs),
+        Element=AmdElements.Element(**kwargs),
+        ImplementationEntry=AmdElements.ImplementationEntry(**kwargs),
+        DataEntry=AmdElements.DataEntry(**kwargs)
+    )
+
+
+def crcClassElement(n:Union[int, str], oid_tag:Optional[Dict[str, str]]=None) -> DataDictionary:
+    n = str(n)
+    if not oid_tag:
+        oid_tag = {}
+    class_id = DataDictionary(
+        componentID={
+            "8": "_040g1ngg01pp1oo708cg4rviuqor2",
+            "16": "_040g1ngg01pp1oo708a0du6locrr2"
+        },
+        implementationOID={
+            "8": "_040g1ngg01pp1oo708cg4rviur2r2",
+            "16": "_040g1ngg01pp1oo708a0du6lq95b2"
+        },
+        dataOID={
+            "8": "_040g1ngg01pp1oo708cg4rviuqvb2",
+            "16": "_040g1ngg01pp1oo708a0du6lod1r2"
+        }
+    )
+    name = f'CRC{n}bit_Calculator'
+    kwargs = DataDictionary(
+        name=name,
+        OID=oid_tag[name] if name in oid_tag else generateOID(),
+        comment=f'CRC {n}bit Calculator Instance',
+        modelType="complex",
+        basicModelType="class",
+        unit="",
+        componentName=f"/HNB_GASOLINE/_29_CommunicationVehicle/CANInterfaceCommon/InterfaceLibrary/CRCCalc/"
+                      f"CRC{n}Bit_Calculator/CRC{n}bit_Calculator",
+        componentID=class_id.componentID[n],
+        scope="local",
+        set="false",
+        get="false",
+        read="true",
+        write="true",
+        reference="false",
+        elementName=f'CRC{n}bit_Calculator',
+        elementOID="",
+        implementationName="Impl",
+        implementationOID=class_id.implementationOID[n],
+        value="false",
+        dataName="Data",
+        dataOID=class_id.dataOID[n]
+    )
+    return elementWrapper(**kwargs)
+
+
+def SignalElement(signal:CanSignal, oid_tag:Optional[Dict[str, str]]=None) -> DataDictionary:
+    if not oid_tag:
+        oid_tag = {}
+    kwargs = DataDictionary()
+    element_name = signal.name if not signal["SignalRenamed"] else signal["SignalRenamed"]
+    kwargs.name = name = f'{element_name}_{"Ems" if signal.ECU == "EMS" else "Can"}'
+    kwargs.OID = oid_tag[name] if name in oid_tag else generateOID()
+    kwargs.comment = signal.Definition
+    if signal.ECU == "EMS":
+        kwargs.comment = ""
+    kwargs.modelType = 'scalar'
+    if signal.Length == 1:
+        kwargs.basicModelType = "log"
+    elif signal.Formula == "OneToOne":
+        kwargs.basicModelType = "udisc"
+    else:
+        kwargs.basicModelType = 'cont'
+    kwargs.unit = signal.Unit
+
+    kwargs.kind = "message"
+    kwargs.scope = "exported"
+    if signal.ECU == "EMS":
+        kwargs.scope = "imported"
+        if signal.isCrc() or signal.isAliveCounter():
+            kwargs.scope = "local"
+
+    kwargs.quantization = "0" if kwargs.basicModelType == "cont" else "1"
+    kwargs.formula = signal.Formula
+
+    size = 8 if signal.Length <= 8 else 16 if signal.Length <= 16 else 32
+    kwargs.physType = "real64" if kwargs.basicModelType == "cont" else "uint32"
+    kwargs.implType = f"sint{size}" if signal["Value Type"].startswith("Signed") else f"uint{size}"
+    kwargs.implMin = f"-{2 ** (size - 1)}" if signal["Value Type"].startswith("Signed") else "0"
+    kwargs.implMax = f"{2 ** (size - 1) - 1}" if signal["Value Type"].startswith("Signed") else f"{2 ** size - 1}"
+
+    if not signal.Formula in F:
+        min_val = int(kwargs.implMin) * signal.Factor + signal.Offset
+        max_val = int(kwargs.implMax) * signal.Factor + signal.Offset
+    else:
+        f = F[signal.Formula]
+        min_val = int(kwargs.implMin) * f.quantization + f.offset
+        max_val = int(kwargs.implMax) * f.quantization + f.offset
+
+    kwargs.physMin = f"{min_val}" if kwargs.basicModelType == "cont" else f"{int(min_val)}"
+    kwargs.physMax = f"{max_val}" if kwargs.basicModelType == "cont" else f"{int(max_val)}"
+    if str(signal.name).startswith("FPCM_ActlPrsrVal"):
+        kwargs.physMax = "800.0"
+    if str(signal.name).startswith("TCU_GrRatioChngProg"):
+        kwargs.physMax = "1.0"
+
+
+    kwargs.value = "false" if kwargs.basicModelType == "log" else "0.0" if kwargs.basicModelType == "cont" else "0"
+    return elementWrapper(**kwargs)
+
+
+class MessageElement:
+
+    __slots__ = [
+        "method",
+        "MethodBody",
+        "buffer",
+        "dlc",
+        "thresholdTime",
+        "counter",
+        "counterCalc",
+        "messageCountTimer",
+        "messageCountValid",
+        "aliveCounter",
+        "aliveCounterCalc",
+        "aliveCountTimer",
+        "aliveCountValid",
+        "crc",
+        "crcCalc",
+        "crcTimer",
+        "crcValid",
+    ]
+
+    def __init__(self, message:CanMessage, oid_tag:Optional[Dict[str, str]]=None):
+        if not oid_tag:
+            oid_tag = {}
+        comment_id = f'{message.name}({message["ID"]})'
+        timer_formula = f"Ti_q{str(message['taskTime']).replace('.', 'p')}_s".replace('p0_s', '_s')
+        timer_round = 3 if message["taskTime"] == 0.001 else 2
+        """
+        신규 Element OID 부여
+        """
+        rule = naming(message.name)
+        for req in self.__slots__:
+            if req.startswith("MethodBody"):
+                continue
+            if req == "aliveCounter":
+                oid_tag[f'{message.aliveCounter.name}_Can'] = oid_tag.get(f'{message.aliveCounter.name}_Can', '') or generateOID()
+                continue
+            if req == "aliveCounterCalc":
+                oid_tag[f'{message.aliveCounter.name}Calc'] = oid_tag.get(f'{message.aliveCounter.name}Calc', '') or generateOID()
+                continue
+            if req == "crc":
+                oid_tag[f'{message.crc.name}_Can'] = oid_tag.get(f'{message.crc.name}_Can', '') or generateOID()
+                continue
+            if req == 'crcCalc':
+                oid_tag[f'{message.crc.name}Calc'] = oid_tag.get(f'{message.crc.name}Calc', '') or generateOID()
+                continue
+
+            if not oid_tag or not getattr(rule, req) in oid_tag:
+                oid_tag[getattr(rule, req)] = generateOID()
+
+        """
+        %ComDef* 모델의 메시지 MethodSignature 생성
+        """
+        self.method = AmdElements.MethodSignature(
+            name=rule.method,
+            OID=oid_tag[rule.method],
+            defaultMethod='true' if str(message.name) == 'ABS_ESC_01_10ms' else 'false'
+        )
+
+        """
+        %ComDef* 모델의 메시지에 대한 MethodBody의 CodeBlock :: C Code 소스
+        """
+        MethodBody = Element('MethodBody', methodName=rule.method, methodOID=oid_tag[rule.method])
+        CodeBlock = Element('CodeBlock')
+        CodeBlock.text = _db2code.MessageCode(message).method
+        MethodBody.append(CodeBlock)
+        self.MethodBody = MethodBody
+
+        """
+        %ComDef* 모델의 메시지 Element
+        """
+        self.buffer = elementWrapper(**DataDictionary(
+            name=rule.buffer,
+            OID=oid_tag[rule.buffer],
+            comment=f'{comment_id} Buffer',
+            modelType="array",
+            basicModelType="udisc",
+            maxSizeX=str(message["DLC"]),
+            kind="variable",
+            scope="exported",
+            quantization="1",
+            formula="OneToOne",
+            physType="uint32", physMin="0", physMax="255",
+            implType="uint8", implMin="0", implMax="255",
+            value="0",
+        ))
+
+        self.dlc = elementWrapper(**DataDictionary(
+            name=rule.dlc,
+            OID=oid_tag[rule.dlc],
+            comment=f'{comment_id} DLC',
+            modelType="scalar",
+            basicModelType="udisc",
+            kind="variable",
+            scope="local",
+            quantization="1",
+            formula="OneToOne",
+            physType="uint32", physMin="0", physMax="255",
+            implType="uint8", implMin="0", implMax="255",
+            value="0",
+        ))
+
+        self.thresholdTime = elementWrapper(**DataDictionary(
+            name=rule.thresholdTime,
+            OID=oid_tag[rule.thresholdTime],
+            comment=f'{comment_id} Timeout Threshold',
+            modelType="scalar",
+            basicModelType="cont",
+            unit="s",
+            kind="parameter",
+            scope="exported",
+            volatile="false",
+            write="false",
+            quantization="0",
+            formula=timer_formula,
+            physType="real64", physMin="0.0", physMax=f'{round(255 * message["taskTime"], timer_round)}',
+            implType="uint8", implMin="0", implMax="255",
+            value=f'{math.ceil(message["timeoutTime"] / message["taskTime"]) * message["taskTime"]: .2f}'
+        ))
+
+        self.counter = elementWrapper(**DataDictionary(
+            name=rule.counter,
+            OID=oid_tag[rule.counter],
+            comment=f'{comment_id} Message Counter',
+            modelType="scalar",
+            basicModelType="udisc",
+            kind="message",
+            scope="exported",
+            quantization="1",
+            formula="OneToOne",
+            physType="uint32", physMin="0", physMax="255",
+            implType="uint8", implMin="0", implMax="255",
+            value="0",
+        ))
+
+        self.counterCalc = elementWrapper(**DataDictionary(
+            name=rule.counterCalc,
+            OID=oid_tag[rule.counterCalc],
+            comment=f'{comment_id} Message Counter Calculated',
+            modelType="scalar",
+            basicModelType="udisc",
+            kind="variable",
+            scope="local",
+            quantization="1",
+            formula="OneToOne",
+            physType="uint32", physMin="0", physMax="255",
+            implType="uint8", implMin="0", implMax="255",
+            value="0",
+        ))
+
+        self.messageCountTimer = elementWrapper(**DataDictionary(
+            name=rule.messageCountTimer,
+            OID=oid_tag[rule.messageCountTimer],
+            comment=f'{comment_id} Counter Timeout Timer',
+            modelType="scalar",
+            basicModelType="cont",
+            unit="s",
+            kind="variable",
+            scope="local",
+            quantization="0",
+            formula=timer_formula,
+            physType="real64", physMin="0.0", physMax=f'{round(255 * message["taskTime"], timer_round)}',
+            implType="uint8", implMin="0", implMax="255",
+            value=f'0.0'
+        ))
+
+        self.messageCountValid = elementWrapper(**DataDictionary(
+            name=rule.messageCountValid,
+            OID=oid_tag[rule.messageCountValid],
+            comment=f'{comment_id} Counter Validity',
+            modelType="scalar",
+            basicModelType="log",
+            kind="message",
+            scope="exported",
+            physType="log",
+            value="false"
+        ))
+
+        if message.hasAliveCounter():
+            self.aliveCounter = SignalElement(message.aliveCounter, oid_tag)
+            attr = xml.to_dict(self.aliveCounter.Element)
+            attr.update(xml.to_dict(self.aliveCounter.ImplementationEntry))
+            attr.update(xml.to_dict(self.aliveCounter.DataEntry))
+            attr.update(
+                name=f'{message.aliveCounter.name}Calc',
+                OID=oid_tag[f'{message.aliveCounter.name}Calc'],
+                comment=f'{comment_id} Alive Counter Calculated',
+                kind='variable',
+                scope='local'
+            )
+            self.aliveCounterCalc = elementWrapper(**attr)
+            self.aliveCountTimer = elementWrapper(**DataDictionary(
+                name=rule.aliveCountTimer,
+                OID=oid_tag[rule.aliveCountTimer],
+                comment=f'{comment_id} Alive Counter Timeout Timer',
+                modelType="scalar",
+                basicModelType="cont",
+                unit="s",
+                kind="variable",
+                scope="local",
+                quantization="0",
+                formula=timer_formula,
+                physType="real64", physMin="0.0", physMax=f'{round(255 * message["taskTime"], timer_round)}',
+                implType="uint8", implMin="0", implMax="255",
+                value=f'0.0'
+            ))
+            self.aliveCountValid = elementWrapper(**DataDictionary(
+                name=rule.aliveCountValid,
+                OID=oid_tag[rule.aliveCountValid],
+                comment=f'{comment_id} Alive Counter Validity',
+                modelType="scalar",
+                basicModelType="log",
+                kind="message",
+                scope="exported",
+                physType="log",
+                value="false"
+            ))
+
+        if message.hasCrc():
+            self.crc = SignalElement(message.crc, oid_tag)
+            attr = xml.to_dict(self.crc.Element)
+            attr.update(xml.to_dict(self.crc.ImplementationEntry))
+            attr.update(xml.to_dict(self.crc.DataEntry))
+            attr.update(
+                name=f'{message.crc.name}Calc',
+                OID=oid_tag[f'{message.crc.name}Calc'],
+                comment=f'{comment_id} CRC Calculated',
+                kind='variable',
+                scope='local'
+            )
+            if message.name == "ESC_01_10ms":
+                attr.update(
+                    kind='message',
+                    scope='exported',
+                )
+            self.crcCalc = elementWrapper(**attr)
+            self.crcTimer = elementWrapper(**DataDictionary(
+                name=rule.crcTimer,
+                OID=oid_tag[rule.crcTimer],
+                comment=f'{comment_id} Alive Counter Timeout Timer',
+                modelType="scalar",
+                basicModelType="cont",
+                unit="s",
+                kind="variable",
+                scope="local",
+                quantization="0",
+                formula=timer_formula,
+                physType="real64", physMin="0.0", physMax=f'{round(255 * message["taskTime"], timer_round)}',
+                implType="uint8", implMin="0", implMax="255",
+                value=f'0.0'
+            ))
+
+            self.crcValid = elementWrapper(**DataDictionary(
+                name=rule.crcValid,
+                OID=oid_tag[rule.crcValid],
+                comment=f'{comment_id} CRC Validity',
+                modelType="scalar",
+                basicModelType="log",
+                kind="message",
+                scope="exported",
+                physType="log",
+                value="false"
+            ))
+
+        return
+
+    def __iter__(self) -> Iterator[DataDictionary]:
+        for slot in self.__slots__:
+            yield self.__getattribute__(slot)
+
+

cannect/core/can/ascet/comdef.py

@@ -0,0 +1,256 @@
+from cannect.config import env
+from cannect.core.ascet.amd import Amd
+from cannect.core.can.ascet import _db2code, _db2elem
+from cannect.core.can.db.reader import CANDBReader
+from cannect.schema.datadictionary import DataDictionary
+from cannect.utils.logger import Logger
+from cannect.utils import tools
+
+from typing import Any, Union, Tuple
+from pandas import DataFrame
+import os, copy
+
+
+class ComDef:
+
+    def __init__(
+        self,
+        db:CANDBReader,
+        engine_spec:str,
+        base_model:str='',
+        exclude_tsw:bool=True,
+    ):
+        exclude_ecus = ["EMS", "CVVD", "MHSG", "NOx"]
+        if engine_spec == "ICE":
+            exclude_ecus += ["BMS", "LDC"]
+        db = db[~db["ECU"].isin(exclude_ecus)]
+        if not db.is_developer_mode():
+            db = db.to_developer_mode(engine_spec)
+
+        if base_model:
+            name = os.path.basename(base_model).split(".")[0]
+        else:
+            name = f"ComDef{'_HEV' if engine_spec == 'HEV' else ''}"
+            base_model = env.SVN_MODEL / rf'HNB_GASOLINE/_29_CommunicationVehicle/StandardDB/NetworkDefinition/{name}/{name}.zip'
+
+        # 공용 속성 생성
+        self.db = db
+        self.name = name
+        self.engine_spec = engine_spec
+
+        # 각 amd의 IO 생성
+        amd = Amd(base_model)
+        self.main = amd.main
+        self.impl = amd.impl
+        self.data = amd.data
+        self.spec = amd.spec
+
+        (env.DOWNLOADS / name).mkdir(exist_ok=True, parents=True)
+        self.logger = logger = Logger(env.DOWNLOADS / rf'{name}/log.txt', clean_record=True)
+        logger.info(f"%{name} MODEL GENERATION")
+        logger.info(f">>> Engine Spec : {engine_spec}")
+        logger.info(f">>> Base Model  : {tools.path_abbreviate(base_model)}")
+        logger.info(f">>> DB Revision : {db.revision}")
+        logger.info(f">>> Exclude TSW : {'Yes' if exclude_tsw else 'No'}")
+
+        """
+        변경 전 모델 요소 수집
+        """
+        logger.info(">>> Collecting Base Model Properties... 0.01s")
+        prev = self.collect_properties()
+        oids = dict(zip(prev.Elements['name'], prev.Elements.index))
+        oids.update(dict(zip(prev.MethodSignature['name'], prev.MethodSignature.index)))
+        self.prev = prev
+        self.oids = oids
+
+        """
+        DB 메시지 기반의 요소 생성
+        """
+        logger.run()
+        self.ME = {name: _db2elem.MessageElement(obj, oid_tag=oids) for name, obj in db.messages.items()}
+        self.MC = {name: _db2code.MessageCode(obj, exclude_tsw) for name, obj in db.messages.items()}
+        logger.end(">>> Defining Message Elements...")
+
+        logger.run()
+        self.SE = [_db2elem.SignalElement(sig, oid_tag=oids) for sig in db.signals.values()]
+        logger.end(">>> Defining Signal Elements...")
+        return
+
+    def autorun(self):
+        self.main.find('Component/Comment').text = _db2code.INFO(self.db.revision)
+        self.define_elements('MethodSignature')
+        self.define_elements('Element')
+        self.define_elements('ImplementationEntry')
+        self.define_elements('DataEntry')
+        self.define_elements('HeaderBlock')
+        self.define_elements('MethodBody')
+        self.export()
+
+        curr = self.collect_properties()
+        deleted = list(set(self.prev.Elements['name']) - set(curr.Elements['name']))
+        added = list(set(curr.Elements['name']) - set(self.prev.Elements['name']))
+        desc = DataFrame(
+            data={
+                ("Method", "Total"): [len(self.prev.MethodSignature), len(self.db.messages)],
+                ("Element", "Total"): [len(self.prev.Elements), len(curr.Elements)],
+                ("Element", "Added"): ["-", len(added)],
+                ("Element", "Deleted"): [len(deleted), "-"]
+            },
+            index=['Base Model', ' New Model']
+        )
+        self.logger.info(">>> Summary\n" + \
+                         desc.to_string() + '\n' + \
+                         f'* Added: {", ".join(added)}' + '\n' + \
+                         f'* Deleted: {", ".join(deleted)}')
+        return
+
+    def collect_properties(self) -> DataDictionary:
+        mainE = self.main.dataframe('Element').set_index(keys='OID').copy()
+        implE = self.impl.dataframe('ImplementationEntry').set_index(keys='elementOID').copy()
+        dataE = self.data.dataframe('DataEntry').set_index(keys='elementOID').copy()
+        implE = implE.drop(columns=[col for col in implE if col in mainE.columns])
+        dataE = dataE.drop(columns=[col for col in dataE if col in mainE.columns or col in implE.columns])
+        return DataDictionary(
+            MethodSignature=self.main.dataframe('MethodSignature').set_index(keys='OID'),
+            MethodBody=self.spec.datadict('MethodBody'),
+            HeaderBlock=self.spec.strictFind('CodeVariant', target="G_HMCEMS").find('HeaderBlock').text,
+            Elements=mainE.join(implE).join(dataE)
+        )
+
+    def parents(self, tag:str) -> Union[Any, Tuple]:
+        if tag == "MethodSignature":
+            return self.main.find('Component/MethodSignatures'), None
+        if tag == "Element":
+            return self.main.find('Component/Elements'), None
+        if tag == 'ImplementationEntry':
+            return tuple(self.impl.findall('ImplementationSet'))
+        if tag == 'DataEntry':
+            return tuple(self.data.findall('DataSet'))
+        if tag == 'MethodBody':
+            return self.spec.strictFind('CodeVariant', target="G_HMCEMS").find('MethodBodies'), \
+                   self.spec.strictFind('CodeVariant', target="PC").find('MethodBodies')
+        if tag == "HeaderBlock":
+            return self.spec.strictFind('CodeVariant', target="G_HMCEMS").find('HeaderBlock'), \
+                   self.spec.strictFind('CodeVariant', target="PC").find('HeaderBlock')
+        raise AttributeError
+
+    def define_elements(self, tag:str):
+        """
+        {tag}에 해당하는 AmdIO를 찾는다.
+        {tag}에 해당하는 AmdIO의 부모 tag를 찾는다.
+        - Implementation 및 Data는 @scope에 따른 부모 tag가 2개 존재한다.
+        부모 tag의 하위 {tag}를 모두 삭제하고 신규 정의 Element로 대체한다.
+
+        :param tag:
+        :return:
+        """
+        pGlob, pLoc = self.parents(tag)
+        for child in list(pGlob):
+            pGlob.remove(child)
+        if pLoc is not None:
+            for child in list(pLoc):
+                pLoc.remove(child)
+
+        if tag == 'MethodSignature':
+            for name in self.db.messages:
+                pGlob.append(self.ME[name].method)
+            return
+
+        if tag == 'HeaderBlock':
+            pLoc.text = "/* Please Change Target In Order To View Source Code */"
+            pGlob.text = f"""#include <Bsw/Include/Bsw.h>
+
+#ifdef SRV_HMCEMS
+{"&lf;".join([mc.srv_name(self.name) for mc in self.MC.values()])}
+#endif
+
+{"&lf;".join([mc.def_name for mc in self.MC.values()])}
+
+{"&lf;".join([mc.struct for mc in self.MC.values()])}
+{_db2code.INLINE}""" \
+    .replace("&tb;", "\t") \
+    .replace("&lf;", "\n")
+            if self.engine_spec == "HEV":
+                pGlob.text = pGlob.text.replace("YRS", "IMU")
+            return
+
+        if tag == "MethodBody":
+            for name, me in self.ME.items():
+                method_body = self.ME[name].MethodBody
+                dummy_method = copy.deepcopy(method_body)
+                dummy_method.find("CodeBlock").text = ""
+                pGlob.append(method_body)
+                pLoc.append(dummy_method)
+            return
+
+        for se in self.SE:
+            pGlob.append(getattr(se, tag))
+
+        for key in _db2elem.MessageElement.__slots__:
+            if key in ["method", "MethodBody", "aliveCounter", "crc"]:
+                continue
+            for name, me in self.ME.items():
+                if hasattr(me, key):
+                    elem = getattr(me, key)
+                    if pLoc is None:
+                        parent = pGlob
+                    else:
+                        parent = pLoc if elem.kwargs.scope == "local" else pGlob
+                    parent.append(getattr(elem, tag))
+
+        parent = pGlob if tag == 'Element' else pLoc
+        parent.append(getattr(_db2elem.crcClassElement(16, self.oids), tag))
+        parent.append(getattr(_db2elem.crcClassElement(8, self.oids), tag))
+        return
+
+    def export(self):
+        self.main.export_to_downloads()
+        self.impl.export_to_downloads()
+        self.data.export_to_downloads()
+        self.spec.export_to_downloads()
+        return
+
+
+if __name__ == "__main__":
+    from pandas import set_option
+    set_option('display.expand_frame_repr', False)
+
+    db = CANDBReader()
+    # db = CANDBReader(env.SVN_CANDB / rf'dev/G-PROJECT_KEFICO-EMS_CANFD_r21676@01.json')
+
+    engine_spec = "HEV"
+
+    # DB CUSTOMIZE ------------------------------------------------------
+    # exclude_ecus = ["EMS", "CVVD", "MHSG", "NOx"]
+    # if engine_spec == "ICE":
+    #     exclude_ecus += ["BMS", "LDC"]
+    # db = db[~db["ECU"].isin(exclude_ecus)]
+
+    # db = db[db["Status"] != "TSW"] # TSW 제외
+    # db = db[~db["Requirement ID"].isin(["VCDM CR10777888"])] # 특정 CR 제외
+    # db = db[~db["Required Date"].isin(["2024-08-27"])] # 특정 일자 제외
+    # db = db[~db["Message"].isin([ # 특정 메시지 제외
+    #     "L_H8L_01_10ms",
+    #     "H8L_01_10ms",
+    #     "H8L_02_10ms",
+    # ])]
+    # db.revision = "TEST SW" # 공식SW는 주석 처리
+    # DB CUSTOMIZE END --------------------------------------------------
+
+    # model = ComDef(
+    #     db=db,
+    #     engine_spec=engine_spec,
+    #     exclude_tsw=True,
+    #     # base_model="",
+    #     # base_model=r'D:\SVN\model\ascet\trunk\HNB_GASOLINE\_29_CommunicationVehicle\StandardDB\NetworkDefinition\ComDef\ComDef-22368\ComDef.main.amd'
+    #     # base_model=ENV['ASCET_EXPORT_PATH']
+    # )
+    # model.autorun()
+
+    model = ComDef(
+        db=db,
+        engine_spec=engine_spec,
+        exclude_tsw=True,
+        # base_model=env.ASCET / f"Export/ComDef_G/ComDef_G.main.amd"
+    )
+    model.autorun()