vss-tools 0.5.0.dev0__py3-none-any.whl

vspec/vssexporters/vss2binary.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2022 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# Convert vspec tree to binary format
+
+import argparse
+import logging
+import ctypes
+import os.path
+from typing import Optional
+from vspec.model.vsstree import VSSNode, VSSType
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+out_file = ""
+_cbinary = None
+
+
+def createBinaryCnode(fname, nodename, nodetype, uuid, description, nodedatatype, nodemin, nodemax, unit, allowed,
+                      defaultAllowed, validate, children):
+    global _cbinary
+    _cbinary.createBinaryCnode(fname, nodename, nodetype, uuid, description, nodedatatype, nodemin, nodemax, unit,
+                               allowed, defaultAllowed, validate, children)
+
+
+def allowedString(allowedList):
+    allowedStr = ""
+    for elem in allowedList:
+        allowedStr += hexAllowedLen(elem) + elem
+#    print("allowedstr=" + allowedStr + "\n")
+    return allowedStr
+
+
+def hexAllowedLen(allowed):
+    hexDigit1 = len(allowed) // 16
+    hexDigit2 = len(allowed) - hexDigit1*16
+#    print("Hexdigs:" + str(hexDigit1) + str(hexDigit2))
+    return "".join([intToHexChar(hexDigit1), intToHexChar(hexDigit2)])
+
+
+def intToHexChar(hexInt):
+    if (hexInt < 10):
+        return chr(hexInt + ord('0'))
+    else:
+        return chr(hexInt - 10 + ord('A'))
+
+
+def export_node(node, generate_uuid, out_file):
+    nodename = str(node.name)
+    b_nodename = nodename.encode('utf-8')
+
+    nodetype = str(node.type.value)
+    b_nodetype = nodetype.encode('utf-8')
+
+    nodedescription = str(node.description)
+    b_nodedescription = nodedescription.encode('utf-8')
+
+    children = len(node.children)
+
+    nodedatatype = ""
+    nodemin = ""
+    nodemax = ""
+    nodeunit = ""
+    nodeallowed = ""
+    nodedefault = ""
+    nodeuuid = ""
+    nodevalidate = ""  # exported to binary
+
+    if node.type == VSSType.SENSOR or node.type == VSSType.ACTUATOR or node.type == VSSType.ATTRIBUTE:
+        nodedatatype = str(node.datatype.value)
+    b_nodedatatype = nodedatatype.encode('utf-8')
+
+    # many optional attributes are initilized to "" in vsstree.py
+    if node.min != "":
+        nodemin = str(node.min)
+    b_nodemin = nodemin.encode('utf-8')
+
+    if node.max != "":
+        nodemax = str(node.max)
+    b_nodemax = nodemax.encode('utf-8')
+
+    if node.allowed != "":
+        nodeallowed = allowedString(node.allowed)
+    b_nodeallowed = nodeallowed.encode('utf-8')
+
+    if node.default != "":
+        nodedefault = str(node.default)
+    b_nodedefault = nodedefault.encode('utf-8')
+
+    # in case of unit or aggregate, the attribute will be missing
+    try:
+        nodeunit = str(node.unit.value)
+    except AttributeError:
+        pass
+    b_nodeunit = nodeunit.encode('utf-8')
+
+    if generate_uuid:
+        nodeuuid = node.uuid
+    b_nodeuuid = nodeuuid.encode('utf-8')
+
+    if "validate" in node.extended_attributes:
+        nodevalidate = node.extended_attributes["validate"]
+    b_nodevalidate = nodevalidate.encode('utf-8')
+
+    b_fname = out_file.encode('utf-8')
+
+    createBinaryCnode(b_fname, b_nodename, b_nodetype, b_nodeuuid, b_nodedescription, b_nodedatatype, b_nodemin,
+                      b_nodemax, b_nodeunit, b_nodeallowed, b_nodedefault, b_nodevalidate, children)
+
+    for child in node.children:
+        export_node(child, generate_uuid, out_file)
+
+
+class Vss2Binary(Vss2X):
+
+    def __init__(self, vspec2vss_config: Vspec2VssConfig):
+        vspec2vss_config.type_tree_supported = False
+        vspec2vss_config.no_expand_option_supported = False
+
+    def generate(self, config: argparse.Namespace, root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        global _cbinary
+        dllName = "../../binary/binarytool.so"
+        dllAbsPath = os.path.dirname(os.path.abspath(__file__)) + os.path.sep + dllName
+        if not os.path.isfile(dllAbsPath):
+            logging.error("The required library binarytool.so is not available, exiting!")
+            logging.info("You must build the library, "
+                         "see https://github.com/COVESA/vss-tools/blob/master/binary/README.md!")
+            return
+        _cbinary = ctypes.CDLL(dllAbsPath)
+
+        _cbinary.createBinaryCnode.argtypes = (ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p,
+                                               ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p,
+                                               ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p,
+                                               ctypes.c_int)
+
+        logging.info("Generating binary output...")
+        out_file = config.output_file
+        export_node(root, vspec2vss_config.generate_uuid, out_file)
+        logging.info("Binary output generated in " + out_file)

vspec/vssexporters/vss2csv.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2021 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# Convert vspec tree to CSV
+
+
+import argparse
+import logging
+from vspec.model.vsstree import VSSNode
+from anytree import PreOrderIter  # type: ignore[import]
+from typing import AnyStr
+from typing import Optional
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+
+# Write the header line
+
+
+def print_csv_header(file, uuid, entry_type: AnyStr, include_instance_column: bool):
+    arg_list = [entry_type, "Type", "DataType", "Deprecated", "Unit",
+                "Min", "Max", "Desc", "Comment", "Allowed", "Default"]
+    if uuid:
+        arg_list.append("Id")
+    if include_instance_column:
+        arg_list.append("Instances")
+    file.write(format_csv_line(arg_list))
+
+# Format a data or header line according to the CSV standard (IETF RFC 4180)
+
+
+def format_csv_line(csv_fields):
+    formatted_csv_line = ""
+    for csv_field in csv_fields:
+        formatted_csv_line = formatted_csv_line + '"' + str(csv_field).replace('"', '""') + '",'
+    return formatted_csv_line[:-1] + '\n'
+
+# Write the data lines
+
+
+def print_csv_content(file, tree: VSSNode, uuid, include_instance_column: bool):
+    tree_node: VSSNode
+    for tree_node in PreOrderIter(tree):
+        data_type_str = tree_node.get_datatype()
+        unit_str = tree_node.get_unit()
+        arg_list = [tree_node.qualified_name('.'), tree_node.type.value, data_type_str, tree_node.deprecation,
+                    unit_str, tree_node.min, tree_node.max, tree_node.description, tree_node.comment,
+                    tree_node.allowed, tree_node.default]
+        if uuid:
+            arg_list.append(tree_node.uuid)
+        if include_instance_column and tree_node.instances is not None:
+            arg_list.append(tree_node.instances)
+        file.write(format_csv_line(arg_list))
+
+
+class Vss2Csv(Vss2X):
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        logging.info("Generating CSV output...")
+
+        # generic entry should be written when both data types and signals are being written to the same file
+        generic_entry = data_type_root is not None and config.types_output_file is None
+        include_instance_column = not vspec2vss_config.expand_model
+        with open(config.output_file, 'w') as f:
+            signal_entry_type = "Node" if generic_entry else "Signal"
+            print_csv_header(f, vspec2vss_config.generate_uuid, signal_entry_type, include_instance_column)
+            print_csv_content(f, signal_root, vspec2vss_config.generate_uuid, include_instance_column)
+            if data_type_root is not None and generic_entry is True:
+                print_csv_content(f, data_type_root, vspec2vss_config.generate_uuid, include_instance_column)
+
+        if data_type_root is not None and generic_entry is False:
+            with open(config.types_output_file, 'w') as f:
+                print_csv_header(f, vspec2vss_config.generate_uuid, "Node", include_instance_column)
+                print_csv_content(f, data_type_root, vspec2vss_config.generate_uuid, include_instance_column)

vspec/vssexporters/vss2ddsidl.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2022 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec files to DDS-IDL
+#
+
+import argparse
+import keyword
+import logging
+from typing import Optional
+
+from vspec.model.vsstree import VSSNode, VSSType
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+c_keywords = [
+    "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else", "enum", "extern", "float",
+    "for", "goto", "if", "int", "long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch",
+    "typedef", "union", "unsigned", "void", "volatile", "while"
+    ]
+
+# Based on http://www.omg.org/spec/IDL/4.2/
+idl_keywords = [
+    "abstract", "any", "alias", "attribute", "bitfield", "bitmask", "bitset", "boolean", "case", "char", "component",
+    "connector", "const", "consumes", "context", "custom", "default", "double", "exception", "emits", "enum",
+    "eventtype", "factory", "FALSE", "finder", "fixed", "float", "getraises", "home", "import", "in", "inout",
+    "interface", "local", "long", "manages", "map", "mirrorport", "module", "multiple", "native", "Object", "octet",
+    "oneway", "out", "primarykey", "private", "port", "porttype", "provides", "public", "publishes", "raises",
+    "readonly", "setraises", "sequence", "short", "string", "struct", "supports", "switch", "TRUE", "truncatable",
+    "typedef", "typeid", "typename", "typeprefix", "unsigned", "union", "uses", "ValueBase", "valuetype", "void",
+    "wchar", "wstring", "int8", "uint8", "int16", "int32", "int64", "uint16", "uint32", "uint64"
+    ]
+
+
+def getAllowedName(name):
+    if (
+        name.lower() in c_keywords
+        or name.lower() in idl_keywords
+        or keyword.iskeyword(name.lower)
+    ):
+        return "_" + name
+    else:
+        return name
+
+
+def get_allowed_enum_literal(name: str):
+    """
+    Check if this is is an allowed literal name, if not add prefix.
+
+    Background:
+
+    In VSS '123' is a perfectly fine string literal, usable as allowed value for a string.
+    The current exporter (this file) translated it previously to 123 which is not a valid DSS IDL literal.
+    Adding an underscore as prefix makes the generated IDL ok, but then gives problems if generating for example
+    Python code by Eclipse Cyclone DDS idlc Python Backend.
+    By that reason we now add a regular character instead.
+    """
+    if name[0].isdigit():
+        return "d" + name
+    return name
+
+
+idlFileBuffer = []
+
+dataTypesMap_covesa_dds = {"uint8": "octet",
+                           "int8": "octet",
+                           "uint16": "unsigned short",
+                           "int16": "short",
+                           "uint32": "unsigned long",
+                           "int32": "long",
+                           "uint64": "unsigned long long",
+                           "int64": "long long",
+                           "boolean": "boolean",
+                           "float": "float",
+                           "double": "double",
+                           "string": "string"
+                           }
+
+
+def export_node(node, generate_uuid, generate_all_idl_features):
+    """
+    This method is used to traverse VSS node and to create corresponding DDS IDL buffer string
+    """
+    global idlFileBuffer
+    datatype = None
+    unit = None
+    min = None
+    max = None
+    defaultValue = None
+    allowedValues = None
+    arraysize = None
+
+    if node.type == VSSType.BRANCH:
+        idlFileBuffer.append("module " + getAllowedName(node.name))
+        idlFileBuffer.append("{")
+        for child in node.children:
+            export_node(child, generate_uuid, generate_all_idl_features)
+        idlFileBuffer.append("};")
+        idlFileBuffer.append("")
+    else:
+        isEnumCreated = False
+        # check if there is a need to create enum (based on the usage of allowed values)
+        if node.allowed != "":
+            """
+            enum should be enclosed under module block to avoid namespec conflict
+            module name for enum is chosen as the node name +
+            """
+            if (node.datatype.value in ["string", "string[]"]):
+                idlFileBuffer.append("module " + getAllowedName(node.name) + "_M")
+                idlFileBuffer.append("{")
+                idlFileBuffer.append("enum " + getAllowedName(node.name) +
+                                     "Values{"+str(",".join(get_allowed_enum_literal(item) for item in node.allowed)) +
+                                     "};")
+                isEnumCreated = True
+                idlFileBuffer.append("};")
+                allowedValues = str(node.allowed)
+            else:
+                print(f"Warning: VSS2IDL can only handle allowed values for string type, "
+                      f"signal {node.name} has type {node.datatype.value}")
+
+        idlFileBuffer.append("struct " + getAllowedName(node.name))
+        idlFileBuffer.append("{")
+        if generate_uuid:
+            idlFileBuffer.append("string uuid;")
+        # fetching value of datatype and obtaining the equivalent DDS type
+        try:
+            datatype_str = node.get_datatype()
+            if node.has_datatype():
+                if datatype_str in dataTypesMap_covesa_dds:
+                    datatype = str(dataTypesMap_covesa_dds[datatype_str])
+                elif '[' in datatype_str:
+                    nodevalueArray = datatype_str.split("[", 1)
+                    if str(nodevalueArray[0]) in dataTypesMap_covesa_dds:
+                        datatype = str(dataTypesMap_covesa_dds[str(nodevalueArray[0])])
+                        arraysize = '[' + str(arraysize) + nodevalueArray[1]
+            else:  # no primitive type. this is custom
+                datatype = datatype_str.replace(".", "::")  # custom data type
+
+        except AttributeError:
+            pass
+        # fetching value of unit
+        try:
+            unit = str(node.unit.value)
+        except AttributeError:
+            pass
+
+        if node.min != "":
+            min = str(node.min)
+        if node.max != "":
+            max = str(node.max)
+        if node.default != "":
+            defaultValue = node.default
+            if isinstance(defaultValue, str) and not isEnumCreated:
+                defaultValue = "\""+defaultValue+"\""
+
+        if datatype is not None:
+            # adding range if min and max are specified in vspec file
+            if min is not None and max is not None and generate_all_idl_features:
+                idlFileBuffer.append("@range(min=" + str(min) + " ,max=" + str(max) + ")")
+
+            if allowedValues is None:
+                if defaultValue is None:
+                    idlFileBuffer.append(
+                        ("sequence<" + datatype + "> value" if arraysize is not None else datatype + " value") + ";")
+                else:
+                    # default values in IDL file are not accepted by CycloneDDS/FastDDS :
+                    # these values can be generated if --all-idl-features is set as True
+                    idlFileBuffer.append(
+                        ("sequence<" + datatype + "> value" if arraysize is not None else datatype + " value") +
+                        ("  default " + str(defaultValue) if generate_all_idl_features else "") + ";")
+            else:
+                # this is the case where allowed values are provided, accordingly contents are converted to enum
+                if defaultValue is None:
+                    idlFileBuffer.append(getAllowedName(node.name)+"_M::"+getAllowedName(node.name)+"Values value;")
+                else:
+                    # default values in IDL file are not accepted by CycloneDDS/FastDDS :
+                    # these values can be generated if --all-idl-features is set as True
+                    idlFileBuffer.append(
+                        getAllowedName(node.name) + "_M::" + getAllowedName(node.name) +
+                        "Values value" + (" " + str(defaultValue) if generate_all_idl_features else "") + ";")
+
+        if unit is not None:
+            idlFileBuffer.append(("" if generate_all_idl_features else "//") + "const string unit=\"" + unit + "\";")
+
+        idlFileBuffer.append(("" if generate_all_idl_features else "//") + "const string type =\"" +
+                             str(node.type.value) + "\";")
+
+        idlFileBuffer.append(("" if generate_all_idl_features else "//") + "const string description=\"" +
+                             node.description + "\";")
+        idlFileBuffer.append("};")
+
+
+class StructExporter(object):
+    """
+    Helper class used for generating export output for struct data types.
+    """
+
+    def __init__(self):
+        self.str_buf = ""
+        self.structs_seen = []
+
+    def export(self, root) -> str:
+        self.str_buf = ""
+        self.structs_seen = []
+        self.export_data_type_node(root)
+        return self.str_buf
+
+    def export_data_type_node(self, node):
+        """
+        This method is used to traverse VSS node and to create corresponding DDS IDL buffer string
+        """
+
+        prefix = ""
+        suffix = ""
+        if node.is_branch():
+            prefix = f"module {getAllowedName(node.name)}" + " {\n"
+            suffix = "};\n"
+        elif node.is_struct():
+            # check if the properties use structs that have not been seen before
+            # if not, add a forward declaration
+            fwds = []
+            for c in node.children:
+                # primtive type
+                if c.has_datatype():
+                    continue
+
+                datatype_str = c.get_datatype().replace('.', '::').split("[", 1)[0]
+                if datatype_str not in self.structs_seen:
+                    base_type = datatype_str.split("::")[-1]
+                    fwds.append(base_type)
+
+            fwds.sort()
+            for f in set(fwds):
+                prefix += f"struct {f};\n"
+
+            prefix += f"struct {getAllowedName(node.name)}" + " {\n"
+            suffix = "};\n"
+            self.structs_seen.append(node.qualified_name("::").split("[", 1)[0])
+        else:
+            datatype_str = node.get_datatype().replace('.', '::').split("[", 1)[0]
+            is_seq = '[' in node.get_datatype()
+            if is_seq:
+                self.str_buf += f"sequence<{datatype_str}> {getAllowedName(node.name)};\n"
+            else:
+                self.str_buf += (f"{datatype_str} {getAllowedName(node.name)};\n")
+
+        self.str_buf += (f"{prefix}")
+
+        for child in node.children:
+            self.export_data_type_node(child)
+        self.str_buf += suffix
+
+
+def export_idl(file, root, generate_uuids=True, generate_all_idl_features=False):
+    """This method is used to traverse through the root VSS node to build
+       -> DDS IDL equivalent string buffer and to serialize it acccordingly into a file
+    """
+    export_node(root, generate_uuids, generate_all_idl_features)
+    file.write('\n'.join(idlFileBuffer))
+    logging.info("IDL file generated at location : " + file.name)
+
+
+class Vss2DdsIdl(Vss2X):
+
+    def __init__(self, vspec2vss_config: Vspec2VssConfig):
+        vspec2vss_config.no_expand_option_supported = False
+        vspec2vss_config.separate_output_type_file_supported = False
+
+    def add_arguments(self, parser: argparse.ArgumentParser):
+        parser.description = "The DDS-IDL exporter"
+        parser.add_argument('--all-idl-features', action='store_true',
+                            help='Generate all features based on DDS IDL 4.2 specification')
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        logging.info("Generating DDS-IDL output...")
+
+        if data_type_root is not None:
+            exporter = StructExporter()
+            with open(config.output_file, 'w') as idl_out:
+                idl_out.write(exporter.export(data_type_root))
+
+        with open(config.output_file, 'a' if data_type_root is not None else 'w') as idl_out:
+            export_idl(idl_out, signal_root, vspec2vss_config.generate_uuid, config.all_idl_features)
+
+    def __del__(self):
+        idlFileBuffer.clear()

vspec/vssexporters/vss2franca.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2021 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# Convert vspec tree to franca
+
+
+import argparse
+from typing import Optional
+from vspec.model.vsstree import VSSNode
+from anytree import PreOrderIter  # type: ignore[import]
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+
+# Write the header line
+
+
+def print_franca_header(file, version="unknown"):
+    file.write(f"""
+// Copyright (C) 2022, COVESA
+//
+// This program is licensed under the terms and conditions of the
+// Mozilla Public License, version 2.0.  The full text of the
+// Mozilla Public License is at https://www.mozilla.org/MPL/2.0/
+
+const UTF8String VSS_VERSION = "{version}"
+
+struct SignalSpec {{
+    UInt32 id
+    String name
+    String type
+    String description
+    String datatype
+    String unit
+    Double min
+    Double max
+}}
+
+const SignalSpec[] signal_spec = [
+""")
+
+
+# Write the data lines
+def print_franca_content(file, tree, uuid):
+    output = ""
+    for tree_node in PreOrderIter(tree):
+        if tree_node.parent:
+            if output:
+                output += ",\n{"
+            else:
+                output += "{"
+            output += f"\tname: \"{tree_node.qualified_name('.')}\""
+            output += f",\n\ttype: \"{tree_node.type.value}\""
+            output += f",\n\tdescription: \"{tree_node.description}\""
+            if tree_node.has_datatype():
+                output += f",\n\tdatatype: \"{tree_node.get_datatype()}\""
+            if uuid:
+                output += f",\n\tuuid: \"{tree_node.uuid}\""
+            if tree_node.has_unit():
+                output += f",\n\tunit: \"{tree_node.get_unit()}\""
+            if tree_node.min:
+                output += f",\n\tmin: {tree_node.min}"
+            if tree_node.max:
+                output += f",\n\tmax: {tree_node.max}"
+            if tree_node.allowed:
+                output += f",\n\tallowed: {tree_node.allowed}"
+
+            output += "\n}"
+    file.write(f"{output}")
+
+
+class Vss2Franca(Vss2X):
+
+    def __init__(self, vspec2vss_config: Vspec2VssConfig):
+        vspec2vss_config.no_expand_option_supported = False
+        vspec2vss_config.type_tree_supported = False
+
+    def add_arguments(self, parser: argparse.ArgumentParser):
+        # Renamed from -v to --franca-vss-version to avoid conflict when using
+        # -vt (Otherwise -vt would be interpreted as "-v t")
+        parser.add_argument('--franca-vss-version', metavar='franca_vss_version',
+                            help=" Add version information to franca file.")
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        print("Generating Franca output...")
+        outfile = open(config.output_file, 'w')
+        print_franca_header(outfile, config.franca_vss_version)
+        print_franca_content(outfile, signal_root, vspec2vss_config.generate_uuid)
+        outfile.write("\n]")
+        outfile.close()