cannect 1.0.0__py3-none-any.whl

cannect/core/can/db/__init__.py

@@ -0,0 +1,4 @@
+from .reader import CANDBReader as Reader
+from .schema import SCHEMA, toJSpreadSheet, standardize
+from .vcs import CANDBVcs as VCS
+from .specification.wrapper import Specification

cannect/core/can/db/reader.py

@@ -0,0 +1,148 @@
+from cannect.core.can.db.schema import SCHEMA
+from cannect.core.can.db.vcs import CANDBVcs
+from cannect.schema.candb import CanSignal, CanMessage
+from cannect.schema.datadictionary import DataDictionary
+
+
+from pandas import DataFrame
+from typing import Dict, Union
+import pandas as pd
+import os
+
+
+class CANDBReader:
+    """
+    CAN DB 데이터프레임
+    데이터프레임 R/W 및 메시지, 신호 단위 접근
+    """
+    def __init__(self, src:Union[str, DataFrame]='', **kwargs):
+        if isinstance(src, DataFrame):
+            source = kwargs["source"] if "source" in kwargs else 'direct'
+            traceability = kwargs["traceability"] if "traceability" in kwargs else 'Untraceable'
+            __db__ = src.copy()
+        else:
+            if not str(src):
+                src = CANDBVcs().json
+            source = src
+            traceability = "_".join(os.path.basename(source).split("_")[:-1])
+            __db__ = pd.read_json(source, orient='index')
+
+        __db__ = __db__[~__db__["Message"].isna()]
+        for col, prop in SCHEMA.items():
+            if col not in __db__.columns:
+                continue
+            if not isinstance(__db__[col].dtype, prop["dtype"]):
+                if prop["dtype"] == float:
+                    __db__[col] = __db__[col].apply(lambda v: 0 if not v else v)
+                try:
+                    __db__[col] = __db__[col].astype(prop["dtype"])
+                except ValueError as e:
+                    raise ValueError(f'Error while type casting :{col} to {prop["dtype"]}; {e}')
+        __db__.fillna("", inplace=True)
+
+        self.db = __db__
+        self.source = source
+        self.traceability = traceability
+        self.revision = traceability.split("_V")[0].split("_")[-1]
+        return
+
+    def __str__(self) -> str:
+        return str(self.db)
+
+    def __repr__(self):
+        return repr(self.db)
+
+    def __getitem__(self, item):
+        __get__ = self.db.__getitem__(item)
+        if isinstance(__get__, DataFrame):
+            return CANDBReader(__get__, source=self.source, traceability=self.traceability)
+        return __get__
+
+    def __len__(self) -> int:
+        return len(self.db)
+
+    def __setitem__(self, key, value):
+        self.db.__setitem__(key, value)
+
+    def __getattr__(self, item):
+        try:
+            return super().__getattribute__(item)
+        except AttributeError:
+            return self.db.__getattr__(item)
+
+    @property
+    def messages(self) -> DataDictionary:
+        return DataDictionary({msg:CanMessage(df) for msg, df in self.db.groupby(by="Message")})
+
+    @property
+    def signals(self) -> Union[Dict[str, CanSignal], DataDictionary]:
+        return DataDictionary({str(sig["Signal"]):CanSignal(sig) for _, sig in self.db.iterrows()})
+
+    def mode(self, engine_spec:str):
+        return CANDBReader(self[self[f'{engine_spec} Channel'] != ""].copy(), source=self.source, traceability=self.traceability)
+
+    def is_developer_mode(self):
+        return "Channel" in self.db.columns
+
+    def to_developer_mode(self, engine_spec:str):
+        """
+        :param engine_spec: ["ICE", "HEV"]
+        :return:
+        """
+        channel = f'{engine_spec} Channel'
+        base = self[self[channel] != ""].copy()
+
+        # Channel P,H 메시지 구분
+        def _msg2chn(msg:str, chn:str) -> str:
+            if not msg.endswith("ms"):
+                return f"{msg}_{chn}"
+            empty = []
+            for part in msg.split("_"):
+                if part.endswith("ms"):
+                    empty.append(chn)
+                empty.append(part)
+            return "_".join(empty)
+
+        base["Channel"] = base[channel]
+        base["WakeUp"] = base[f"{engine_spec} WakeUp"]
+        base["Signal"] = base[["Signal", "SignalRenamed"]].apply(
+            lambda x: x["SignalRenamed"] if x["SignalRenamed"] else x["Signal"],
+            axis=1
+        )
+
+        multi_channel_message = base[base[channel].str.contains(',')]['Message'].unique()
+        objs = [base]
+        for msg in multi_channel_message:
+            signals = base[base["Message"] == msg]
+            channels = []
+            for chn in signals[channel].unique():
+                if len(chn) >= len(channels):
+                    channels = chn.split(",")
+            for chn in channels:
+                unique = signals[signals[channel].str.contains(chn)].copy()
+                unique["Message"] = unique["Message"].apply(lambda x: _msg2chn(x, chn))
+                unique["Signal"] = unique["Signal"] + f"_{chn}"
+                unique["SignalRenamed"] = unique["SignalRenamed"].apply(lambda x: x + f"_{chn}" if x else "")
+                unique["Channel"] = chn
+                objs.append(unique)
+
+        base = pd.concat(objs=objs, axis=0, ignore_index=True)
+        base = base[~base["Message"].isin(multi_channel_message)]
+        return CANDBReader(base, source=self.source, traceability=self.traceability)
+
+
+if __name__ == "__main__":
+    from pandas import set_option
+    set_option('display.expand_frame_repr', False)
+
+    db = CANDBReader()
+    # print(db)
+    print(db.source)
+    print(db.traceability)
+    print(db.revision)
+    # print(db.to_developer_mode("ICE").revision)
+    # print(db.messages['ABS_ESC_01_10ms'])
+    # print(db.columns)
+    # print(db.is_developer_mode())
+    # db2 = db.to_developer_mode("HEV")
+    # print(db2[db2["Message"].str.contains("MCU")])

cannect/core/can/db/schema.py

@@ -0,0 +1,269 @@
+from cannect.schema.datadictionary import DataDictionary
+from pandas import Index
+
+
+SCHEMA =__meta__ = DataDictionary({
+    "ECU":{
+        "synonyms": ["ecu", "controller", "sender", "tx", "송출제어기"],
+        "dtype": str,
+        "width": 100,
+        "align": "center",
+    },
+    "Message":{
+        "synonyms": ["message", "msg"],
+        "dtype": str,
+        "width": 140,
+        "align": "center",
+    },
+    "ID":{
+        "synonyms": ["id"],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "DLC":{
+        "synonyms": ["dlc"],
+        "dtype": int,
+        "width": 30,
+        "align": "center",
+    },
+    "Send Type":{
+        "synonyms": ["sendtype"],
+        "dtype": str,
+        "width": 30,
+        "align": "center",
+    },
+    "Cycle Time":{
+        "synonyms": ["cycletime"],
+        "dtype": int,
+        "width": 30,
+        "align": "center",
+    },
+    "Signal":{
+        "synonyms": ["signal", "sig"],
+        "dtype": str,
+        "width": 200,
+        "align": "left",
+    },
+    "Definition":{
+        "synonyms": ["definition"],
+        "dtype": str,
+        "width": 240,
+        "align": "left",
+    },
+    "Length":{
+        "synonyms": ["length", "Length\n(Bit)"],
+        "dtype": int,
+        "width": 30,
+        "align": "center",
+    },
+    "StartBit":{
+        "synonyms": ["startbit", "Startbit", "address"],
+        "dtype": int,
+        "width": 30,
+        "align": "center",
+    },
+    "Sig Receivers":{
+        "synonyms": ["Destination", "receiver"],
+        "dtype": str,
+        "width": 80,
+        "align": "left",
+    },
+    "UserSigValidity":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "Value Table":{
+        "synonyms": ["table"],
+        "dtype": str,
+        "width": 140,
+        "align": "left",
+    },
+    "Value Type":{
+        "synonyms": ["type"],
+        "dtype": str,
+        "width": 80,
+        "align": "center",
+    },
+    "GenSigStartValue":{
+        "synonyms": ["startvalue", "initialValue", "initial"],
+        "dtype": str,
+        "width": 80,
+        "align": "center",
+    },
+    "Factor":{
+        "synonyms": ["factor"],
+        "dtype": float,
+        "width": 60,
+        "align": "center",
+    },
+    "Offset":{
+        "synonyms": ["offset"],
+        "dtype": float,
+        "width": 60,
+        "align": "center",
+    },
+    "Min":{
+        "synonyms": ["min"],
+        "dtype": float,
+        "width": 60,
+        "align": "center",
+    },
+    "Max":{
+        "synonyms": ["max"],
+        "dtype": float,
+        "width": 60,
+        "align": "center",
+    },
+    "Unit":{
+        "synonyms": ["unit"],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "Local Network Wake Up Request":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 40,
+        "align": "center",
+    },
+    "Network Request Holding Time":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 30,
+        "align": "center",
+    },
+    "Description":{
+        "synonyms": ["description"],
+        "dtype": str,
+        "width": 100,
+        "align": "left",
+    },
+    "Version":{
+        "synonyms": ["version"],
+        "dtype": str,
+        "width": 80,
+        "align": "center",
+    },
+    "Requirement ID": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 100,
+        "align": "center",
+    },
+    "Required Date": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "Remark": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 100,
+        "align": "center",
+    },
+    "Status": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "ByteOrder": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 80,
+        "align": "center",
+    },
+    "ICE Channel":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "ICE WakeUp":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "HEV Channel":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "HEV WakeUp": {
+        "synonyms": [],
+        "dtype": str,
+        "width": 60,
+        "align": "center",
+    },
+    "SystemConstant":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 160,
+        "align": "center",
+    },
+    "Codeword":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 160,
+        "align": "center",
+    },
+    "Formula":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 140,
+        "align": "center",
+    },
+    "SignedProcessing":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 100,
+        "align": "center",
+    },
+    "InterfacedVariable":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 200,
+        "align": "left",
+    },
+    "SignalRenamed":{
+        "synonyms": [],
+        "dtype": str,
+        "width": 200,
+        "align": "left",
+    },
+})
+
+
+def standardize(columns: Index) -> list:
+    standard_columns = []
+    for col in __meta__:
+        if col in columns:
+            standard_columns.append(col)
+            continue
+        for synonym in __meta__[col].synonyms:
+            if synonym in columns:
+                standard_columns.append(col)
+        if not col in standard_columns:
+            raise KeyError(f"Cannot find {col} in columns; {columns}")
+    return standard_columns
+
+
+def toJSpreadSheet(columns: Index=None) -> list:
+    if columns is None:
+        columns = list(__meta__.keys())
+    else:
+        columns = standardize(columns)
+
+    return [{
+        "type": "text",
+        "width": __meta__[col].width,
+        "title": col,
+        "align": __meta__[col].align
+    } for col in columns]
+

cannect/core/can/db/specification/message.py

@@ -0,0 +1,230 @@
+from cannect.schema.candb import CanMessage
+
+from docx.document import Document
+from docx.styles.styles import Styles
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from docx.shared import Inches, Pt, RGBColor
+from docx.oxml import parse_xml
+from docx.oxml.ns import nsdecls
+from typing import List
+
+
+class Message:
+    COLORS = [
+        'C4BC96',
+        '8DB3E2',
+        'B8CCE4',
+        'E5B8B7',
+        'D6E3BC',
+        'CCC0D9',
+        'FBD4B4',
+        'B6DDE8'
+    ]
+
+    def __init__(self, doc:Document):
+        self.doc:Document = doc
+        return
+
+    def _coloring(self, msg:CanMessage) -> List[str]:
+        colors = ['A6A6A6'] * msg['DLC'] * 8
+        for n in range(msg['DLC'] * 8):
+            for m, sig in enumerate(msg):
+                if sig['StartBit'] <= n < (sig['StartBit'] + sig['Length']):
+                    colors[n] = self.COLORS[m % len(self.COLORS)]
+                    break
+        return colors
+
+    @property
+    def messageOverviewStyle(self) -> Styles:
+        if not hasattr(self, "_overview_style"):
+            style = self.doc.styles.add_style("_overview_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(11)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = True
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+            self.__setattr__("_overview_style", style)
+        return self.__getattribute__("_overview_style")
+
+    @property
+    def messageOverviewContentStyle(self) -> Styles:
+        if not hasattr(self, "_overview_content_style"):
+            style = self.doc.styles.add_style("_overview_content_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(11)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = False
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+            self.__setattr__("_overview_content_style", style)
+        return self.__getattribute__("_overview_content_style")
+
+    @property
+    def messageLayoutNumberStyle(self) -> Styles:
+        if not hasattr(self, "_layout_number_style"):
+            style = self.doc.styles.add_style("_layout_number_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(9)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = True
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+            self.__setattr__("_layout_number_style", style)
+        return self.__getattribute__("_layout_number_style")
+
+    @property
+    def messageLayoutStyle(self) -> Styles:
+        if not hasattr(self, "_layout_style"):
+            style = self.doc.styles.add_style("_layout_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(7)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = False
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+            self.__setattr__("_layout_style", style)
+        return self.__getattribute__("_layout_style")
+
+    @property
+    def signalListHeadingStyle(self) -> Styles:
+        if not hasattr(self, "_signal_style"):
+            style = self.doc.styles.add_style("_signal_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(10)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = True
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+            self.__setattr__("_signal_style", style)
+        return self.__getattribute__("_signal_style")
+
+    @property
+    def signalListStyle(self) -> Styles:
+        if not hasattr(self, "_signal_content_style"):
+            style = self.doc.styles.add_style("_signal_content_style", WD_PARAGRAPH_ALIGNMENT.CENTER)
+            style.font.name = "현대산스 text"
+            style.font.size = Pt(10)
+            style.font.color.rgb = RGBColor(0, 0, 0)
+            style.font.bold = False
+            style.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+            self.__setattr__("_signal_content_style", style)
+        return self.__getattribute__("_signal_content_style")
+
+    def addHeading(
+        self,
+        text:str,
+        level:int=1,
+        fontSize:int=20,
+        bold:bool=True,
+        alignCenter:bool=True
+    ):
+        heading = self.doc.add_heading(text, level=level)
+        if alignCenter:
+            heading.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        runner = heading.runs[0]
+        runner.font.name = "현대산스 Text"
+        runner.font.size = Pt(fontSize)
+        runner.font.bold = bold
+        runner.font.color.rgb = RGBColor(0, 0, 0)
+        return
+
+    def addMessageHeading(self, msg:CanMessage):
+        self.addHeading(f"{msg['ID']}: {msg.name}", level=2, fontSize=14, alignCenter=False)
+        return
+
+    def addMessageSpec(self, msg:CanMessage):
+        specs = {
+            "ECU": "SENDER",
+            "ID": "ID",
+            "Message": "MESSAGE",
+            "DLC": "DLC",
+            "Send Type": "SEND TYPE",
+            "Cycle Time": "CYCLE TIME [ms]",
+            "ByteOrder": "BYTE ORDER",
+            "SystemConstant": "SYSCON",
+            "Codeword": "CODEWORD"
+        }
+        self.addHeading("Message Overview", level=3, fontSize=12, bold=True, alignCenter=False)
+        table = self.doc.add_table(rows=len(specs), cols=2)
+        table.style = 'Table Grid'
+        for n, (key, value) in enumerate(specs.items()):
+            left = table.rows[n].cells[0]
+            left.width = Inches(2.0)
+            name = left.paragraphs[0]
+            name.text = value
+            name.style = self.messageOverviewStyle
+
+            right = table.rows[n].cells[1]
+            right.width = self.doc.sections[0].page_width
+            text = right.paragraphs[0]
+            text.text = str(msg[key])
+            text.style = self.messageOverviewContentStyle
+        return
+
+    def addMessageLayout(self, msg:CanMessage):
+        self.addHeading("Message Layout", level=3, fontSize=12, bold=True, alignCenter=False)
+        color = self._coloring(msg)
+        table = self.doc.add_table(rows=msg['DLC'] * 2, cols=8)
+        for n, row in enumerate(table.rows):
+            byte = int(n / 2)
+            for m, cell in enumerate(row.cells):
+                bit = 8 * byte + 7 - m
+                sig = msg.signals[msg.signals["StartBit"] == int(bit)]
+                sig = '' if sig.empty else sig.iloc[0]["Signal"]
+
+                text = cell.paragraphs[0]
+                text.text = str(bit) if not n % 2 else sig
+                text.style = self.messageLayoutNumberStyle if not n % 2 else self.messageLayoutStyle
+                cell._tc.get_or_add_tcPr().append(
+                    parse_xml(r'<w:shd {} w:fill="{}"/>'.format(nsdecls('w'), color[bit]))
+                )
+        return
+
+    def addSignalList(self, msg:CanMessage):
+        specs = {
+            "Signal": "Signal",
+            "InterfacedVariable": "@EMS",
+            "Length": "Len.",
+            "StartBit": "Addr.",
+            "Value Type": "Type",
+            "Factor": "Factor",
+            "Offset": "Offset",
+            "Unit": "Unit"
+        }
+        self.addHeading("Signal List", level=3, fontSize=12, bold=True, alignCenter=False)
+        table = self.doc.add_table(rows=len(msg.signals) + 1, cols=8)
+        table.style = "Table Grid"
+        for n, row in enumerate(table.rows):
+            for m, key in enumerate(specs.keys()):
+                if not n:
+                    text = row.cells[m].paragraphs[0]
+                    text.text = specs[key]
+                    text.style = self.signalListHeadingStyle
+                else:
+                    text = row.cells[m].paragraphs[0]
+                    text.text = str(msg.signals.iloc[n - 1][key]).replace('"', '')
+                    text.style = self.signalListStyle
+        return
+
+    def addSignalProperty(self, msg:CanMessage):
+        specs = {
+            "Signal": "Signal",
+            "Definition": "Definition",
+            "Value Table": "Value Table"
+        }
+        self.addHeading("Signal Property", level=3, fontSize=12, bold=True, alignCenter=False)
+
+        for sig in msg:
+            table = self.doc.add_table(rows=3, cols=2)
+            table.style = 'Table Grid'
+            for n, (key, value) in enumerate(specs.items()):
+                left = table.rows[n].cells[0]
+                left.width = Inches(2.0)
+                name = left.paragraphs[0]
+                name.text = value
+                name.style = self.messageOverviewStyle
+
+                right = table.rows[n].cells[1]
+                right.width = self.doc.sections[0].page_width
+                text = right.paragraphs[0]
+                text.text = sig[key].replace("/0x", "\n0x") if key == "Value Table" else sig[key]
+                text.style = self.messageOverviewContentStyle
+            self.doc.add_paragraph()
+        self.doc.add_paragraph("\n")
+        return